/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.1
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */

// We want to suppress warnings in the auto-generated CXX file.
#if defined(_MSC_VER)
#   pragma warning(disable : 4244) // warning C4244: 'initializing' : conversion from 'Py_ssize_t' to 'const int', possible loss of data
#   pragma warning(disable : 4267) // warning C4267: 'initializing' : conversion from 'size_t' to 'const unsigned int', possible loss of data
#endif  // _MSC_VER



#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif

#define SWIG_DIRECTORS
#define SWIG_PYTHON_THREADS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif


#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows to return the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
#define SWIG_ERROR                 (-1)
#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/*  Errors in SWIG */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13



/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)	
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

#ifndef Py_TYPE
#  define Py_TYPE(op) ((op)->ob_type)
#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif


/* Warning: This function will allocate a new string in Python 3,
 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 */
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03000000
  char *newstr = 0;
  str = PyUnicode_AsUTF8String(str);
  if (str) {
    char *cstr;
    Py_ssize_t len;
    PyBytes_AsStringAndSize(str, &cstr, &len);
    newstr = (char *) malloc(len+1);
    memcpy(newstr, cstr, len+1);
    Py_XDECREF(str);
  }
  return newstr;
#else
  return PyString_AsString(str);
#endif
}

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
#else
#  define SWIG_Python_str_DelForPy3(x) 
#endif


SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
// interface files check for it.
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
  PyObject* type = 0;
  switch(code) {
  case SWIG_MemoryError:
    type = PyExc_MemoryError;
    break;
  case SWIG_IOError:
    type = PyExc_IOError;
    break;
  case SWIG_RuntimeError:
    type = PyExc_RuntimeError;
    break;
  case SWIG_IndexError:
    type = PyExc_IndexError;
    break;
  case SWIG_TypeError:
    type = PyExc_TypeError;
    break;
  case SWIG_DivisionByZero:
    type = PyExc_ZeroDivisionError;
    break;
  case SWIG_OverflowError:
    type = PyExc_OverflowError;
    break;
  case SWIG_SyntaxError:
    type = PyExc_SyntaxError;
    break;
  case SWIG_ValueError:
    type = PyExc_ValueError;
    break;
  case SWIG_SystemError:
    type = PyExc_SystemError;
    break;
  case SWIG_AttributeError:
    type = PyExc_AttributeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    const char *tmp = SWIG_Python_str_AsChar(old_str);
    PyErr_Clear();
    Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
  PyObject *error;
  if (obj)
    return 0;
  error = PyErr_Occurred();
  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}

SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
  if (SWIG_Python_TypeErrorOccurred(NULL)) {
    /* Use existing TypeError to preserve stacktrace and enhance with given message */
    PyObject *newvalue;
    PyObject *type = NULL, *value = NULL, *traceback = NULL;
    PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
    newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
    Py_XDECREF(value);
    PyErr_Restore(type, newvalue, traceback);
  } else {
    /* Raise TypeError using given message */
    PyErr_SetString(PyExc_TypeError, message);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    define SWIG_PYTHON_USE_GIL
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

/* -----------------------------------------------------------------------------
 * Python API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  const char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;

#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif

#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
# error "This version of SWIG only supports Python 3 >= 3.2"
#endif

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   


/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      PyList_SetItem(result, 0, o2);
    }
    PyList_Append(result,obj);
    Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      Py_ssize_t i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      Py_ssize_t i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      data->newargs = obj;
      Py_INCREF(obj);
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
	Py_INCREF(data->newraw);
	data->newargs = PyTuple_New(1);
	PyTuple_SetItem(data->newargs, 0, obj);
      } else {
	data->newargs = obj;
      }
      Py_INCREF(data->newargs);
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      int flags;
      Py_INCREF(data->destroy);
      flags = PyCFunction_GET_FLAGS(data->destroy);
      data->delargs = !(flags & (METH_O));
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data) {
  Py_XDECREF(data->newraw);
  Py_XDECREF(data->newargs);
  Py_XDECREF(data->destroy);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->dict)
    sobj->dict = PyDict_New();

  Py_INCREF(sobj->dict);
  return sobj->dict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
	res = PyUnicode_Format(ofmt,args);
#else
	res = PyString_Format(ofmt,args);
#endif
	Py_DECREF(ofmt);
      }
      Py_DECREF(args);
    }
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# if PY_VERSION_HEX >= 0x03000000
    PyObject *joined = PyUnicode_Concat(repr, nrep);
    Py_DecRef(repr);
    Py_DecRef(nrep);
    repr = joined;
# else
    PyString_ConcatAndDel(&repr,nrep);
# endif
  }
  return repr;  
}

/* We need a version taking two PyObject* parameters so it's a valid
 * PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
  void *i = v->ptr;
  void *j = w->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res;
  if( op != Py_EQ && op != Py_NE ) {
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  }
  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  return res;  
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
  PyTypeObject *target_tp = SwigPyObject_type();
  if (PyType_IsSubtype(op->ob_type, target_tp))
    return 1;
  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
  return (Py_TYPE(op) == SwigPyObject_type())
    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *type = NULL, *value = NULL, *traceback = NULL;
      PyErr_Fetch(&type, &value, &traceback);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        res = SWIG_Python_CallFunctor(destroy, tmp);
        Py_DECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(type, value, traceback);

      Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
  } 
  Py_XDECREF(next);
  PyObject_DEL(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        SwigPyObject_acquire(v,args);
      } else {
        SwigPyObject_disown(v,args);
      }
    } 
    return obj;
  }
}

static PyMethodDef
swigobject_methods[] = {
  {"disown",  SwigPyObject_disown,  METH_NOARGS,  "releases ownership of the pointer"},
  {"acquire", SwigPyObject_acquire, METH_NOARGS,  "acquires ownership of the pointer"},
  {"own",     SwigPyObject_own,     METH_VARARGS, "returns/sets ownership of the pointer"},
  {"append",  SwigPyObject_append,  METH_O,       "appends another 'this' object"},
  {"next",    SwigPyObject_next,    METH_NOARGS,  "returns the next 'this' object"},
  {"__repr__",SwigPyObject_repr2,   METH_NOARGS,  "returns object representation"},
  {0, 0, 0, 0}  
};

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";

  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyObject",                       /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
      0,                                    /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigobject_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      swigobject_methods,                   /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) < 0)
      return NULL;
  }
  return &swigpyobject_type;
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_DEL(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyPacked",                       /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
      0,                                    /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigpacked_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) < 0)
      return NULL;
  }
  return &swigpypacked_type;
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_DEL((PyObject *) sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

static PyObject *Swig_This_global = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (Swig_This_global == NULL)
    Swig_This_global = SWIG_Python_str_FromChar("this");
  return Swig_This_global;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
# ifdef PyWeakref_CheckProxy
  if (PyWeakref_CheckProxy(pyobj)) {
    pyobj = PyWeakref_GET_OBJECT(pyobj);
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  return NULL;
#else

  obj = 0;

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
#ifdef PyWeakref_CheckProxy
      if (PyWeakref_CheckProxy(pyobj)) {
	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
#endif
      obj = PyObject_GetAttr(pyobj,SWIG_This());
      if (obj) {
	Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (own)
      *own = *own | sobj->own;
    if (flags & SWIG_POINTER_DISOWN) {
      sobj->own = 0;
    }
    res = SWIG_OK;
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            Py_DECREF(impconv);
          }
        }
      }
      if (!SWIG_IsOK(res) && obj == Py_None) {
        if (ptr)
          *ptr = 0;
        if (PyErr_Occurred())
          PyErr_Clear();
        res = SWIG_OK;
      }
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    swig_cast_info *tc;

    /* here we get the method pointer for callbacks */
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    if (!desc)
      return SWIG_ERROR;
    tc = SWIG_TypeCheck(desc,ty);
    if (tc) {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    } else {
      return SWIG_ERROR;
    }
    return SWIG_OK;
  }
}

/* Convert a packed pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
	PyObject *dict = *dictptr;
	if (dict == NULL) {
	  dict = PyDict_New();
	  *dictptr = dict;
	  PyDict_SetItem(dict, SWIG_This(), swig_this);
	}
      }
#else
      PyObject *key = SWIG_This();
      PyObject_SetAttr(inst, key, swig_this);
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
        inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        Py_DECREF(empty_kwargs);
        if (inst) {
          PyObject_SetAttr(inst, SWIG_This(), swig_this);
          Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
        }
      }
      Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
 PyObject *dict;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
 PyObject **dictptr = _PyObject_GetDictPtr(inst);
 if (dictptr != NULL) {
   dict = *dictptr;
   if (dict == NULL) {
     dict = PyDict_New();
     *dictptr = dict;
   }
   PyDict_SetItem(dict, SWIG_This(), swig_this);
   return;
 }
#endif
 dict = PyObject_GetAttrString(inst, "__dict__");
 PyDict_SetItem(dict, SWIG_This(), swig_this);
 Py_DECREF(dict);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SwigPyObject_append((PyObject*) sthis, obj[1]);
    } else {
      SWIG_Python_SetSwigThis(obj[0], obj[1]);
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
        newobj->dict = 0;
#endif
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
      newobj->dict = 0;
#endif
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
#ifdef SWIG_LINK_RUNTIME
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
#else
    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
    if (PyErr_Occurred()) {
      PyErr_Clear();
      type_pointer = (void *)0;
    }
#endif
  }
  return (swig_module_info *) type_pointer;
}

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      if (data) SwigPyClientData_Del(data);
    }
  }
  Py_DECREF(SWIG_This());
  Swig_This_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
}

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
  return cache;
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      PyDict_SetItem(cache, key, obj);
      Py_DECREF(obj);
    }
  }
  Py_DECREF(key);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      const char *tmp = SWIG_Python_str_AsChar(old_str);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Python_str_DelForPy3(tmp);
      Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
          SWIG_Python_str_DelForPy3(cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	Py_XDECREF(str);
	return;
      }
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
#if SWIG_POINTER_EXCEPTION
    if (flags) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      SWIG_Python_ArgFail(argnum);
    }
#endif
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = obj->ob_type;
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    return -1;
  } else {
    Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) < 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = descr->ob_type->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        return -1;
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 



#ifdef __cplusplus
extern "C" {
#endif

/* Method creation and docstring support functions */

SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);

#ifdef __cplusplus
}
#endif


  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 

/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that Python proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

#include <string>
#include <iostream>
#include <exception>
#include <vector>
#include <map>


/*
  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
  table', and avoid multiple GetAttr calls to retrieve the python
  methods.
*/

#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
#define SWIG_PYTHON_DIRECTOR_VTABLE
#endif
#endif



/*
  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swig.
*/
#ifndef SWIG_DIRECTOR_NO_UEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif


/*
  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
  native C++ RTTI and dynamic_cast<>. But be aware that directors
  could stop working when using this option.
*/
#ifdef SWIG_DIRECTOR_NORTTI
/*
   When we don't use the native C++ RTTI, we implement a minimal one
   only for Directors.
*/
# ifndef SWIG_DIRECTOR_RTDIR
# define SWIG_DIRECTOR_RTDIR

namespace Swig {
  class Director;
  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
    static std::map<void *, Director *> rtdir_map;
    return rtdir_map;
  }

  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
    get_rtdir_map()[vptr] = rtdir;
  }

  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
    std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
    return rtdir;
  }
}
# endif /* SWIG_DIRECTOR_RTDIR */

# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)

#else

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

  /* memory handler */
  struct GCItem {
    virtual ~GCItem() {}

    virtual int get_own() const {
      return 0;
    }
  };

  struct GCItem_var {
    GCItem_var(GCItem *item = 0) : _item(item) {
    }

    GCItem_var& operator=(GCItem *item) {
      GCItem *tmp = _item;
      _item = item;
      delete tmp;
      return *this;
    }

    ~GCItem_var() {
      delete _item;
    }

    GCItem * operator->() const {
      return _item;
    }

  private:
    GCItem *_item;
  };

  struct GCItem_Object : GCItem {
    GCItem_Object(int own) : _own(own) {
    }

    virtual ~GCItem_Object() {
    }

    int get_own() const {
      return _own;
    }

  private:
    int _own;
  };

  template <typename Type>
  struct GCItem_T : GCItem {
    GCItem_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCItem_T() {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

  template <typename Type>
  struct GCArray_T : GCItem {
    GCArray_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCArray_T() {
      delete[] _ptr;
    }

  private:
    Type *_ptr;
  };

  /* base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;
  public:
    DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (msg[0]) {
        swig_msg += " ";
        swig_msg += msg;
      }
      if (!PyErr_Occurred()) {
        PyErr_SetString(error, what());
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
    }

    virtual ~DirectorException() throw() {
    }

    /* Deprecated, use what() instead */
    const char *getMessage() const {
      return what();
    }

    const char *what() const throw() {
      return swig_msg.c_str();
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorException(error, msg);
    }

    static void raise(const char *msg) {
      raise(PyExc_RuntimeError, msg);
    }
  };

  /* type mismatch in the return value from a python method call */
  class DirectorTypeMismatchException : public DirectorException {
  public:
    DirectorTypeMismatchException(PyObject *error, const char *msg="")
      : DirectorException(error, "SWIG director type mismatch", msg) {
    }

    DirectorTypeMismatchException(const char *msg="")
      : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorTypeMismatchException(error, msg);
    }

    static void raise(const char *msg) {
      throw DirectorTypeMismatchException(msg);
    }
  };

  /* any python exception that occurs during a director method call */
  class DirectorMethodException : public DirectorException {
  public:
    DirectorMethodException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorMethodException(msg);
    }
  };

  /* attempt to call a pure virtual method via a director method */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorPureVirtualException(msg);
    }
  };


#if defined(SWIG_PYTHON_THREADS)
/*  __THREAD__ is the old macro to activate some thread support */
# if !defined(__THREAD__)
#   define __THREAD__ 1
# endif
#endif

#ifdef __THREAD__
# include "pythread.h"
  class Guard {
    PyThread_type_lock &mutex_;

  public:
    Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
      PyThread_acquire_lock(mutex_, WAIT_LOCK);
    }

    ~Guard() {
      PyThread_release_lock(mutex_);
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex)
#endif

  /* director base class */
  class Director {
  private:
    /* pointer to the wrapped python object */
    PyObject *swig_self;
    /* flag indicating whether the object is owned by python or c++ */
    mutable bool swig_disown_flag;

    /* decrement the reference count of the wrapped python object */
    void swig_decref() const {
      if (swig_disown_flag) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        Py_DECREF(swig_self);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }

  public:
    /* wrap a python object. */
    Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
    }

    /* discard our reference at destruction */
    virtual ~Director() {
      swig_decref();
    }

    /* return a pointer to the wrapped python object */
    PyObject *swig_get_self() const {
      return swig_self;
    }

    /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
    void swig_disown() const {
      if (!swig_disown_flag) {
        swig_disown_flag=true;
        swig_incref();
      }
    }

    /* increase the reference count of the wrapped python object */
    void swig_incref() const {
      if (swig_disown_flag) {
        Py_INCREF(swig_self);
      }
    }

    /* methods to implement pseudo protected director members */
    virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
      return true;
    }

    virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
    }

  /* ownership management */
  private:
    typedef std::map<void *, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
#ifdef __THREAD__
    static PyThread_type_lock swig_mutex_own;
#endif

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }

    template <typename Type>
    void swig_acquire_ownership(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_T<Type>(vptr);
      }
    }

    void swig_acquire_ownership_obj(void *vptr, int own) const {
      if (vptr && own) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_Object(own);
      }
    }

    int swig_release_ownership(void *vptr) const {
      int own = 0;
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_ownership_map::iterator iter = swig_owner.find(vptr);
        if (iter != swig_owner.end()) {
          own = iter->second->get_own();
          swig_owner.erase(iter);
        }
      }
      return own;
    }

    template <typename Type>
    static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
      SwigPyObject *sobj = (SwigPyObject *)pyobj;
      sobj->own = 0;
      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
      if (d)
        d->swig_disown();
      return PyWeakref_NewProxy(pyobj, NULL);
    }
  };

#ifdef __THREAD__
  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
#endif
}

#endif

/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_char swig_types[0]
#define SWIGTYPE_p_first_type swig_types[1]
#define SWIGTYPE_p_int swig_types[2]
#define SWIGTYPE_p_int16_t swig_types[3]
#define SWIGTYPE_p_int32_t swig_types[4]
#define SWIGTYPE_p_long swig_types[5]
#define SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters swig_types[6]
#define SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettings swig_types[7]
#define SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI swig_types[8]
#define SWIGTYPE_p_mvIMPACT__acquire__BufferPart swig_types[9]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase swig_types[10]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionCameraLink swig_types[11]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigital swig_types[12]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase swig_types[13]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2 swig_types[14]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager swig_types[15]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard swig_types[16]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionSDI swig_types[17]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandard swig_types[18]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandardBase swig_types[19]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBase swig_types[20]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR swig_types[21]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice swig_types[22]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX swig_types[23]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber swig_types[24]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device swig_types[25]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice swig_types[26]
#define SWIGTYPE_p_mvIMPACT__acquire__ChannelData swig_types[27]
#define SWIGTYPE_p_mvIMPACT__acquire__Component swig_types[28]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess swig_types[29]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback swig_types[30]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentCollection swig_types[31]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentList swig_types[32]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator swig_types[33]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase swig_types[34]
#define SWIGTYPE_p_mvIMPACT__acquire__Connector swig_types[35]
#define SWIGTYPE_p_mvIMPACT__acquire__Device swig_types[36]
#define SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator swig_types[37]
#define SWIGTYPE_p_mvIMPACT__acquire__DeviceManager swig_types[38]
#define SWIGTYPE_p_mvIMPACT__acquire__DigitalIOMeasurementControl swig_types[39]
#define SWIGTYPE_p_mvIMPACT__acquire__DigitalInput swig_types[40]
#define SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput swig_types[41]
#define SWIGTYPE_p_mvIMPACT__acquire__ECantAccessData swig_types[42]
#define SWIGTYPE_p_mvIMPACT__acquire__ECantAllocateNewList swig_types[43]
#define SWIGTYPE_p_mvIMPACT__acquire__ECantRegisterComponent swig_types[44]
#define SWIGTYPE_p_mvIMPACT__acquire__ECantSerializeData swig_types[45]
#define SWIGTYPE_p_mvIMPACT__acquire__EComponent swig_types[46]
#define SWIGTYPE_p_mvIMPACT__acquire__EComponentIDInvalid swig_types[47]
#define SWIGTYPE_p_mvIMPACT__acquire__EComponentNotFound swig_types[48]
#define SWIGTYPE_p_mvIMPACT__acquire__EDeviceManager swig_types[49]
#define SWIGTYPE_p_mvIMPACT__acquire__EImplementationMissing swig_types[50]
#define SWIGTYPE_p_mvIMPACT__acquire__EIncompatibleComponents swig_types[51]
#define SWIGTYPE_p_mvIMPACT__acquire__EInputBufferTooSmall swig_types[52]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidFileContent swig_types[53]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidInputParameter swig_types[54]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidListID swig_types[55]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidParameterList swig_types[56]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidValue swig_types[57]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidValueType swig_types[58]
#define SWIGTYPE_p_mvIMPACT__acquire__EListEntryOccupied swig_types[59]
#define SWIGTYPE_p_mvIMPACT__acquire__EMethod swig_types[60]
#define SWIGTYPE_p_mvIMPACT__acquire__EMethodPtrInvalid swig_types[61]
#define SWIGTYPE_p_mvIMPACT__acquire__ENoModifySizeRights swig_types[62]
#define SWIGTYPE_p_mvIMPACT__acquire__ENoReadRights swig_types[63]
#define SWIGTYPE_p_mvIMPACT__acquire__ENoWriteRights swig_types[64]
#define SWIGTYPE_p_mvIMPACT__acquire__ENotAList swig_types[65]
#define SWIGTYPE_p_mvIMPACT__acquire__ENotAMethod swig_types[66]
#define SWIGTYPE_p_mvIMPACT__acquire__ENotAProperty swig_types[67]
#define SWIGTYPE_p_mvIMPACT__acquire__EProperty swig_types[68]
#define SWIGTYPE_p_mvIMPACT__acquire__EPropertyHandling swig_types[69]
#define SWIGTYPE_p_mvIMPACT__acquire__EPropertyList swig_types[70]
#define SWIGTYPE_p_mvIMPACT__acquire__ESizeMismatch swig_types[71]
#define SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableCorrupted swig_types[72]
#define SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableNotDefined swig_types[73]
#define SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedOperation swig_types[74]
#define SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedParameter swig_types[75]
#define SWIGTYPE_p_mvIMPACT__acquire__EValIDOutOfBounds swig_types[76]
#define SWIGTYPE_p_mvIMPACT__acquire__EValTooLarge swig_types[77]
#define SWIGTYPE_p_mvIMPACT__acquire__EValTooSmall swig_types[78]
#define SWIGTYPE_p_mvIMPACT__acquire__EValidationFailed swig_types[79]
#define SWIGTYPE_p_mvIMPACT__acquire__EWrongParamCount swig_types[80]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t swig_types[81]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t swig_types[82]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t swig_types[83]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t swig_types[84]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t swig_types[85]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t swig_types[86]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t swig_types[87]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t swig_types[88]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t swig_types[89]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t swig_types[90]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t swig_types[91]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t swig_types[92]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t swig_types[93]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t swig_types[94]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t swig_types[95]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t swig_types[96]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t swig_types[97]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t swig_types[98]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t swig_types[99]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t swig_types[100]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t swig_types[101]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t swig_types[102]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t swig_types[103]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t swig_types[104]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t swig_types[105]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t swig_types[106]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t swig_types[107]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t swig_types[108]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t swig_types[109]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t swig_types[110]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t swig_types[111]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t swig_types[112]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t swig_types[113]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t swig_types[114]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t swig_types[115]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t swig_types[116]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t swig_types[117]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t swig_types[118]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t swig_types[119]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t swig_types[120]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t swig_types[121]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t swig_types[122]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t swig_types[123]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t swig_types[124]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t swig_types[125]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t swig_types[126]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t swig_types[127]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t swig_types[128]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t swig_types[129]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t swig_types[130]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t swig_types[131]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t swig_types[132]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t swig_types[133]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t swig_types[134]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAutoNegotiatePacketSizeMode_t swig_types[135]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t swig_types[136]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t swig_types[137]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t swig_types[138]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t swig_types[139]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t swig_types[140]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t swig_types[141]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t swig_types[142]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t swig_types[143]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t swig_types[144]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t swig_types[145]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t swig_types[146]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t swig_types[147]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t swig_types[148]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t swig_types[149]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t swig_types[150]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t swig_types[151]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t swig_types[152]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t swig_types[153]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t swig_types[154]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t swig_types[155]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t swig_types[156]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t swig_types[157]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t swig_types[158]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t swig_types[159]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t swig_types[160]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t swig_types[161]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t swig_types[162]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t swig_types[163]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t swig_types[164]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t swig_types[165]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t swig_types[166]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t swig_types[167]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t swig_types[168]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t swig_types[169]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t swig_types[170]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t swig_types[171]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t swig_types[172]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t swig_types[173]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t swig_types[174]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t swig_types[175]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t swig_types[176]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t swig_types[177]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t swig_types[178]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t swig_types[179]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t swig_types[180]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t swig_types[181]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t swig_types[182]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t swig_types[183]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t swig_types[184]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t swig_types[185]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t swig_types[186]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t swig_types[187]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t swig_types[188]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t swig_types[189]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t swig_types[190]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t swig_types[191]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t swig_types[192]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t swig_types[193]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t swig_types[194]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t swig_types[195]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t swig_types[196]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t swig_types[197]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t swig_types[198]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t swig_types[199]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t swig_types[200]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t swig_types[201]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t swig_types[202]
#define SWIGTYPE_p_mvIMPACT__acquire__ExceptionFactory swig_types[203]
#define SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater swig_types[204]
#define SWIGTYPE_p_mvIMPACT__acquire__FullSettingsBase swig_types[205]
#define SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface swig_types[206]
#define SWIGTYPE_p_mvIMPACT__acquire__GainOffsetKneeChannelParameters swig_types[207]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl swig_types[208]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl swig_types[209]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl swig_types[210]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl swig_types[211]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl swig_types[212]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl swig_types[213]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator swig_types[214]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule swig_types[215]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl swig_types[216]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl swig_types[217]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule swig_types[218]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl swig_types[219]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl swig_types[220]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl swig_types[221]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl swig_types[222]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator swig_types[223]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration swig_types[224]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl swig_types[225]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule swig_types[226]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl swig_types[227]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl swig_types[228]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl swig_types[229]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl swig_types[230]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl swig_types[231]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl swig_types[232]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__SoftwareSignalControl swig_types[233]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__SourceControl swig_types[234]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule swig_types[235]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__TestControl swig_types[236]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl swig_types[237]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl swig_types[238]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl swig_types[239]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl swig_types[240]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCurrentControl swig_types[241]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl swig_types[242]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl swig_types[243]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl swig_types[244]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl swig_types[245]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl swig_types[246]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl swig_types[247]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl swig_types[248]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl swig_types[249]
#define SWIGTYPE_p_mvIMPACT__acquire__HDRControl swig_types[250]
#define SWIGTYPE_p_mvIMPACT__acquire__HDRKneePoint swig_types[251]
#define SWIGTYPE_p_mvIMPACT__acquire__I2CControl swig_types[252]
#define SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem swig_types[253]
#define SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX swig_types[254]
#define SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemCommon swig_types[255]
#define SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber swig_types[256]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer swig_types[257]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc swig_types[258]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageDestination swig_types[259]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager swig_types[260]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing swig_types[261]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl swig_types[262]
#define SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException swig_types[263]
#define SWIGTYPE_p_mvIMPACT__acquire__Info swig_types[264]
#define SWIGTYPE_p_mvIMPACT__acquire__InfoBlueCOUGAR swig_types[265]
#define SWIGTYPE_p_mvIMPACT__acquire__InfoBlueDevice swig_types[266]
#define SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX swig_types[267]
#define SWIGTYPE_p_mvIMPACT__acquire__LUTParameters swig_types[268]
#define SWIGTYPE_p_mvIMPACT__acquire__Method swig_types[269]
#define SWIGTYPE_p_mvIMPACT__acquire__MirrorParameters swig_types[270]
#define SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl swig_types[271]
#define SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice swig_types[272]
#define SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber swig_types[273]
#define SWIGTYPE_p_mvIMPACT__acquire__Property swig_types[274]
#define SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr swig_types[275]
#define SWIGTYPE_p_mvIMPACT__acquire__PropertyS swig_types[276]
#define SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration swig_types[277]
#define SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram swig_types[278]
#define SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep swig_types[279]
#define SWIGTYPE_p_mvIMPACT__acquire__Request swig_types[280]
#define SWIGTYPE_p_mvIMPACT__acquire__RequestFactory swig_types[281]
#define SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration swig_types[282]
#define SWIGTYPE_p_mvIMPACT__acquire__SettingsBlueFOX swig_types[283]
#define SWIGTYPE_p_mvIMPACT__acquire__SettingsFrameGrabber swig_types[284]
#define SWIGTYPE_p_mvIMPACT__acquire__Statistics swig_types[285]
#define SWIGTYPE_p_mvIMPACT__acquire__SyncOutput swig_types[286]
#define SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX swig_types[287]
#define SWIGTYPE_p_mvIMPACT__acquire__SystemSettings swig_types[288]
#define SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2 swig_types[289]
#define SWIGTYPE_p_mvIMPACT__acquire__TriggerControl swig_types[290]
#define SWIGTYPE_p_mvIMPACT__acquire__UserData swig_types[291]
#define SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry swig_types[292]
#define SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings swig_types[293]
#define SWIGTYPE_p_mvIMPACT__acquire__WhiteBalancer swig_types[294]
#define SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream swig_types[295]
#define SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStreamPauseScope swig_types[296]
#define SWIGTYPE_p_second_type swig_types[297]
#define SWIGTYPE_p_std__invalid_argument swig_types[298]
#define SWIGTYPE_p_std__mapT_std__string_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t_t swig_types[299]
#define SWIGTYPE_p_std__pairT_std__string_double_t swig_types[300]
#define SWIGTYPE_p_std__pairT_std__string_int_t swig_types[301]
#define SWIGTYPE_p_std__pairT_std__string_long_t swig_types[302]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t swig_types[303]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t swig_types[304]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t swig_types[305]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t swig_types[306]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t swig_types[307]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t swig_types[308]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t swig_types[309]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t swig_types[310]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t swig_types[311]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t swig_types[312]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t swig_types[313]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t swig_types[314]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t swig_types[315]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t swig_types[316]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t swig_types[317]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t swig_types[318]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t swig_types[319]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t swig_types[320]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t swig_types[321]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t swig_types[322]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t swig_types[323]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t swig_types[324]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t swig_types[325]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t swig_types[326]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t swig_types[327]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t swig_types[328]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t swig_types[329]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t swig_types[330]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t swig_types[331]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t swig_types[332]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t swig_types[333]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t swig_types[334]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t swig_types[335]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t swig_types[336]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t swig_types[337]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t swig_types[338]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t swig_types[339]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t swig_types[340]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t swig_types[341]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t swig_types[342]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t swig_types[343]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t swig_types[344]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t swig_types[345]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t swig_types[346]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t swig_types[347]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t swig_types[348]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t swig_types[349]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t swig_types[350]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t swig_types[351]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t swig_types[352]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t swig_types[353]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t swig_types[354]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t swig_types[355]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t swig_types[356]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t swig_types[357]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t swig_types[358]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t swig_types[359]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t swig_types[360]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t swig_types[361]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t swig_types[362]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t swig_types[363]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t swig_types[364]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t swig_types[365]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t swig_types[366]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t swig_types[367]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t swig_types[368]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t swig_types[369]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t swig_types[370]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t swig_types[371]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t swig_types[372]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t swig_types[373]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t swig_types[374]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t swig_types[375]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t swig_types[376]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t swig_types[377]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t swig_types[378]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t swig_types[379]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t swig_types[380]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t swig_types[381]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t swig_types[382]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t swig_types[383]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t swig_types[384]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t swig_types[385]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t swig_types[386]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t swig_types[387]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t swig_types[388]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t swig_types[389]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t swig_types[390]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t swig_types[391]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t swig_types[392]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t swig_types[393]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t swig_types[394]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t swig_types[395]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t swig_types[396]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t swig_types[397]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t swig_types[398]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t swig_types[399]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t swig_types[400]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t swig_types[401]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t swig_types[402]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t swig_types[403]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t swig_types[404]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t swig_types[405]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t swig_types[406]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t swig_types[407]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t swig_types[408]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t swig_types[409]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t swig_types[410]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t swig_types[411]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t swig_types[412]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t swig_types[413]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t swig_types[414]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t swig_types[415]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t swig_types[416]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t swig_types[417]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t swig_types[418]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t swig_types[419]
#define SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t swig_types[420]
#define SWIGTYPE_p_std__runtime_error swig_types[421]
#define SWIGTYPE_p_std__string swig_types[422]
#define SWIGTYPE_p_std__vectorT_mvIMPACT__acquire__Component_std__allocatorT_mvIMPACT__acquire__Component_t_t swig_types[423]
#define SWIGTYPE_p_std__vectorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_std__allocatorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_t_t swig_types[424]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_std__allocatorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t_t swig_types[425]
#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[426]
#define SWIGTYPE_p_std__vectorT_void_p_std__allocatorT_void_p_t_t swig_types[427]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[428]
#define SWIGTYPE_p_uint16_t swig_types[429]
#define SWIGTYPE_p_uint32_t swig_types[430]
#define SWIGTYPE_p_unsigned_long swig_types[431]
#define SWIGTYPE_p_void swig_types[432]
static swig_type_info *swig_types[434];
static swig_module_info swig_module = {swig_types, 433, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

/*-----------------------------------------------
              @(target):= lib_mvIMPACT_acquire.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit_lib_mvIMPACT_acquire

#else
#  define SWIG_init    initlib_mvIMPACT_acquire

#endif
#define SWIG_name    "lib_mvIMPACT_acquire"

#define SWIGVERSION 0x040001 
#define SWIG_VERSION SWIGVERSION


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


namespace swig {
  class SwigPtr_PyObject {
  protected:
    PyObject *_obj;

  public:
    SwigPtr_PyObject() :_obj(0)
    {
    }

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(_obj);      
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(item._obj);
      Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XDECREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
    {
      return _obj;
    }

    PyObject *operator->() const
    {
      return _obj;
    }
  };
}


namespace swig {
  struct SwigVar_PyObject : SwigPtr_PyObject {
    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    
    SwigVar_PyObject & operator = (PyObject* obj)
    {
      Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


#include <typeinfo>
#include <stdexcept>


#if defined(__GNUC__)
#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
#     define SWIG_STD_NOMODERN_STL
#  endif
#endif


#include <string>


#include <stddef.h>


#include <utility>


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
#else
# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#endif


namespace swig {
  struct stop_iteration {
  };

  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

  protected:
    SwigPyIterator(PyObject *seq) : _seq(seq)
    {
    }
      
  public:
    virtual ~SwigPyIterator() {}

    // Access iterator method, required by Python
    virtual PyObject *value() const = 0;

    // Forward iterator method, required by Python
    virtual SwigPyIterator *incr(size_t n = 1) = 0;
    
    // Backward iterator method, very common in C++, but not required in Python
    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    {
      throw stop_iteration();
    }

    // Random access iterator methods, but not required in Python
    virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }

    virtual bool equal (const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }
    
    // C++ common/needed methods
    virtual SwigPyIterator *copy() const = 0;

    PyObject *next()     
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      PyObject *obj = value();
      incr();       
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
      return obj;     
    }

    /* Make an alias for Python 3.x */
    PyObject *__next__()
    {
      return next();
    }

    PyObject *previous()
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      decr();
      PyObject *obj = value();
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
      return obj;
    }

    SwigPyIterator *advance(ptrdiff_t n)
    {
      return  (n > 0) ?  incr(n) : decr(-n);
    }
      
    bool operator == (const SwigPyIterator& x)  const
    {
      return equal(x);
    }
      
    bool operator != (const SwigPyIterator& x) const
    {
      return ! operator==(x);
    }
      
    SwigPyIterator& operator += (ptrdiff_t n)
    {
      return *advance(n);
    }

    SwigPyIterator& operator -= (ptrdiff_t n)
    {
      return *advance(-n);
    }
      
    SwigPyIterator* operator + (ptrdiff_t n) const
    {
      return copy()->advance(n);
    }

    SwigPyIterator* operator - (ptrdiff_t n) const
    {
      return copy()->advance(-n);
    }
      
    ptrdiff_t operator - (const SwigPyIterator& x) const
    {
      return x.distance(*this);
    }
      
    static swig_type_info* descriptor() {
      static int init = 0;
      static swig_type_info* desc = 0;
      if (!init) {
	desc = SWIG_TypeQuery("swig::SwigPyIterator *");
	init = 1;
      }	
      return desc;
    }    
  };

#if defined(SWIGPYTHON_BUILTIN)
  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
  {
    Py_INCREF(pyself);
    return pyself;
  }
#endif
}


SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx = floor(x);
   double cx = ceil(x);
   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}


  #define SWIG_From_long   PyInt_FromLong 


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_long_SS_long  (long long value)
{
  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    return SWIG_From_long  (static_cast< long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
    return SWIG_From_long_SS_long  (static_cast< long long >(value));
  }
#endif
}


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    long long v = PyLong_AsLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    long v;
    res = SWIG_AsVal_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    const double mant_min = -mant_max;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
      if (val) *val = (long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    long v;
    res = SWIG_AsVal_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
    long long v;
    res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  }
#endif
  return res;
}


#include <algorithm>


#include <vector>


#define MVIMPACT_USE_NAMESPACES
#include <mvIMPACT_CPP/mvIMPACT_acquire_GenICam_CustomCommands.h>
#if defined(SWIGJAVA) || defined(DOXYGEN_JAVA_DOCUMENTATION)
#   include <mvIMPACT_CPP/mvIMPACT_acquire_GenICam_LensControl.h>
#endif
#if defined(_MSC_VER) || defined(DOXYGEN_JAVA_DOCUMENTATION) || defined(DOXYGEN_PYTHON_DOCUMENTATION) // is Microsoft compiler or are we building the Java or Python manual?
#   include <mvDisplay/Include/mvIMPACT_acquire_display.h>
#endif

using namespace mvIMPACT::acquire;


static void handleImpactAcquireException(const mvIMPACT::acquire::ImpactAcquireException &e) {
    switch( e.getErrorCode() ) {
        case PROPHANDLING_NOT_A_LIST:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ENotAList), SWIG_NewPointerObj(new mvIMPACT::acquire::ENotAList(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__ENotAList, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_NOT_A_PROPERTY:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ENotAProperty), SWIG_NewPointerObj(new mvIMPACT::acquire::ENotAProperty(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__ENotAProperty, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_NOT_A_METHOD:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ENotAMethod), SWIG_NewPointerObj(new mvIMPACT::acquire::ENotAMethod(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__ENotAMethod, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_NO_READ_RIGHTS:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ENoReadRights), SWIG_NewPointerObj(new mvIMPACT::acquire::ENoReadRights(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__ENoReadRights, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_NO_WRITE_RIGHTS:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ENoWriteRights), SWIG_NewPointerObj(new mvIMPACT::acquire::ENoWriteRights(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__ENoWriteRights, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_NO_MODIFY_SIZE_RIGHTS:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ENoModifySizeRights), SWIG_NewPointerObj(new mvIMPACT::acquire::ENoModifySizeRights(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__ENoModifySizeRights, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_INCOMPATIBLE_COMPONENTS:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EIncompatibleComponents), SWIG_NewPointerObj(new mvIMPACT::acquire::EIncompatibleComponents(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__EIncompatibleComponents, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_UNSUPPORTED_PARAMETER:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedParameter), SWIG_NewPointerObj(new mvIMPACT::acquire::EUnsupportedParameter(e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedParameter, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_SIZE_MISMATCH:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ESizeMismatch), SWIG_NewPointerObj(new mvIMPACT::acquire::ESizeMismatch(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__ESizeMismatch, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_IMPLEMENTATION_MISSING:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EImplementationMissing), SWIG_NewPointerObj(new mvIMPACT::acquire::EImplementationMissing(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EImplementationMissing, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_INVALID_PROP_VALUE:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EInvalidValue), SWIG_NewPointerObj(new mvIMPACT::acquire::EInvalidValue(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__EInvalidValue, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_PROP_TRANSLATION_TABLE_CORRUPTED:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableCorrupted), SWIG_NewPointerObj(new mvIMPACT::acquire::ETranslationTableCorrupted(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableCorrupted, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_PROP_VAL_ID_OUT_OF_BOUNDS:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EValIDOutOfBounds), SWIG_NewPointerObj(new mvIMPACT::acquire::EValIDOutOfBounds(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__EValIDOutOfBounds, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_PROP_TRANSLATION_TABLE_NOT_DEFINED:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableNotDefined), SWIG_NewPointerObj(new mvIMPACT::acquire::ETranslationTableNotDefined(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableNotDefined, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_INVALID_PROP_VALUE_TYPE:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EInvalidValueType), SWIG_NewPointerObj(new mvIMPACT::acquire::EInvalidValueType(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__EInvalidValueType, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_PROP_VAL_TOO_LARGE:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EValTooLarge), SWIG_NewPointerObj(new mvIMPACT::acquire::EValTooLarge(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EValTooLarge, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_PROP_VAL_TOO_SMALL:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EValTooSmall), SWIG_NewPointerObj(new mvIMPACT::acquire::EValTooSmall(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EValTooSmall, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_COMPONENT_NOT_FOUND:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EComponentNotFound), SWIG_NewPointerObj(new mvIMPACT::acquire::EComponentNotFound(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EComponentNotFound, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_LIST_ID_INVALID:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EInvalidListID), SWIG_NewPointerObj(new mvIMPACT::acquire::EInvalidListID(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EInvalidListID, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_COMPONENT_ID_INVALID:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EComponentIDInvalid), SWIG_NewPointerObj(new mvIMPACT::acquire::EComponentIDInvalid(e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EComponentIDInvalid, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_LIST_ENTRY_OCCUPIED:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EListEntryOccupied), SWIG_NewPointerObj(new mvIMPACT::acquire::EListEntryOccupied(e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EListEntryOccupied, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_LIST_CANT_ACCESS_DATA:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ECantAccessData), SWIG_NewPointerObj(new mvIMPACT::acquire::ECantAccessData(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__ECantAccessData, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_METHOD_PTR_INVALID:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EMethodPtrInvalid), SWIG_NewPointerObj(new mvIMPACT::acquire::EMethodPtrInvalid(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__EMethodPtrInvalid, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_METHOD_INVALID_PARAM_LIST:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EInvalidParameterList), SWIG_NewPointerObj(new mvIMPACT::acquire::EInvalidParameterList(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EInvalidParameterList, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_INVALID_INPUT_PARAMETER:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EInvalidInputParameter), SWIG_NewPointerObj(new mvIMPACT::acquire::EInvalidInputParameter(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EInvalidInputParameter, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_INPUT_BUFFER_TOO_SMALL:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EInputBufferTooSmall), SWIG_NewPointerObj(new mvIMPACT::acquire::EInputBufferTooSmall(e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EInputBufferTooSmall, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_WRONG_PARAM_COUNT:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EWrongParamCount), SWIG_NewPointerObj(new mvIMPACT::acquire::EWrongParamCount(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EWrongParamCount, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_UNSUPPORTED_OPERATION:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedOperation), SWIG_NewPointerObj(new mvIMPACT::acquire::EUnsupportedOperation(e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedOperation, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_CANT_SERIALIZE_DATA:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ECantSerializeData), SWIG_NewPointerObj(new mvIMPACT::acquire::ECantSerializeData(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__ECantSerializeData, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_INVALID_FILE_CONTENT:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EInvalidFileContent), SWIG_NewPointerObj(new mvIMPACT::acquire::EInvalidFileContent(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__EInvalidFileContent, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_CANT_ALLOCATE_LIST:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ECantAllocateNewList), SWIG_NewPointerObj(new mvIMPACT::acquire::ECantAllocateNewList(e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__ECantAllocateNewList, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_CANT_REGISTER_COMPONENT:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ECantRegisterComponent), SWIG_NewPointerObj(new mvIMPACT::acquire::ECantRegisterComponent(e.getErrorString(), e.getErrorOrigin()), SWIGTYPE_p_mvIMPACT__acquire__ECantRegisterComponent, SWIG_POINTER_OWN));
            break;
        case PROPHANDLING_PROP_VALIDATION_FAILED:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EValidationFailed), SWIG_NewPointerObj(new mvIMPACT::acquire::EValidationFailed(e.getErrorString(), e.getErrorOrigin(), false), SWIGTYPE_p_mvIMPACT__acquire__EValidationFailed, SWIG_POINTER_OWN));
            break;
        // unsupported:
        //PROPHANDLING_ACCESSTOKEN_CREATION_FAILED          = -2011
        //PROPHANDLING_COMPONENT_HAS_OWNER_ALREADY          = -2023,
        //PROPHANDLING_COMPONENT_ALREADY_REGISTERED         = -2024,
        //PROPHANDLING_SWIG_ERROR                           = -2028,
        //PROPHANDLING_COMPONENT_NO_CALLBACK_REGISTERED     = -2030,
        case DMR_DEV_NOT_FOUND:
        case DMR_INIT_FAILED:
        case DMR_DRV_ALREADY_IN_USE:
        case DMR_DEV_CANNOT_OPEN:
        case DMR_NOT_INITIALIZED:
        case DMR_DRV_CANNOT_OPEN:
        case DMR_DEV_REQUEST_QUEUE_EMPTY:
        case DMR_DEV_REQUEST_CREATION_FAILED:
        case DMR_INVALID_PARAMETER:
        case DMR_EXPORTED_SYMBOL_NOT_FOUND:
        case DEV_UNKNOWN_ERROR:
        case DEV_HANDLE_INVALID:
        case DEV_INPUT_PARAM_INVALID:
        case DEV_WRONG_INPUT_PARAM_COUNT:
        case DEV_CREATE_SETTING_FAILED:
        case DEV_REQUEST_CANT_BE_UNLOCKED:
        case DEV_INVALID_REQUEST_NUMBER:
        case DEV_LOCKED_REQUEST_IN_QUEUE:
        case DEV_NO_FREE_REQUEST_AVAILABLE:
        case DEV_WAIT_FOR_REQUEST_FAILED:
        case DEV_UNSUPPORTED_PARAMETER:
        case DEV_INVALID_RTC_NUMBER:
        case DMR_INTERNAL_ERROR:
        case DMR_INPUT_BUFFER_TOO_SMALL:
        case DEV_INTERNAL_ERROR:
        case DMR_LIBRARY_NOT_FOUND:
        case DMR_FUNCTION_NOT_IMPLEMENTED:
        case DMR_FEATURE_NOT_AVAILABLE:
        case DMR_EXECUTION_PROHIBITED:
        case DMR_FILE_NOT_FOUND:
        case DMR_INVALID_LICENCE:
        case DEV_SENSOR_TYPE_ERROR:
        case DMR_CAMERA_DESCRIPTION_INVALID:
        case DMR_NEWER_LIBRARY_REQUIRED:
        case DMR_TIMEOUT:
        case DMR_WAIT_ABANDONED:
        case DMR_EXECUTION_FAILED:
        case DEV_REQUEST_ALREADY_IN_USE:
        case DEV_REQUEST_BUFFER_INVALID:
        case DEV_REQUEST_BUFFER_MISALIGNED:
        case DEV_ACCESS_DENIED:
        case DMR_PRELOAD_CHECK_FAILED:
        case DMR_FILE_ACCESS_ERROR:
        case DMR_CAMERA_DESCRIPTION_INVALID_PARAMETER:
        case DMR_INVALID_QUEUE_SELECTION:
        case DMR_ACQUISITION_ENGINE_BUSY:
        case DMR_BUSY:
        case DMR_OUT_OF_MEMORY:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__EDeviceManager), SWIG_NewPointerObj(new mvIMPACT::acquire::EDeviceManager(e.getErrorString(), e.getErrorOrigin(), static_cast<mvIMPACT::acquire::TDMR_ERROR>(e.getErrorCode())), SWIGTYPE_p_mvIMPACT__acquire__EDeviceManager, SWIG_POINTER_OWN));
            break;
        default:
            SWIG_SetErrorObj(SWIG_Python_ExceptionType(SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException), SWIG_NewPointerObj(new mvIMPACT::acquire::ImpactAcquireException(e), SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, SWIG_POINTER_OWN));
            break;
    }
}


template<typename T> PyObject* CToPyObject                                  (const T& v)                                { return PyInt_FromLong(v); };
template<>           PyObject* CToPyObject<float>                           (const float&  v)                           { return PyFloat_FromDouble(v); };
template<>           PyObject* CToPyObject<double>                          (const double& v)                           { return PyFloat_FromDouble(v); };
template<>           PyObject* CToPyObject<std::string>                     (const std::string& v)                      { return PyString_FromString(v.c_str()); };


SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}


SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}


SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (!alloc && cptr) {
        /* We can't allow converting without allocation, since the internal
           representation of string in Python 3 is UCS-2/UCS-4 but we require
           a UTF-8 representation.
           TODO(bhy) More detailed explanation */
        return SWIG_RuntimeError;
    }
    obj = PyUnicode_AsUTF8String(obj);
    if (!obj)
      return SWIG_TypeError;
    if (alloc)
      *alloc = SWIG_NEWOBJ;
#endif
    PyBytes_AsStringAndSize(obj, &cstr, &len);
#else
    PyString_AsStringAndSize(obj, &cstr, &len);
#endif
    if (cptr) {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
	  *alloc = SWIG_NEWOBJ;
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
	*cptr = PyBytes_AsString(obj);
#else
	assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
	*cptr = SWIG_Python_str_AsChar(obj);
        if (!*cptr)
          ret = SWIG_TypeError;
#endif
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    Py_XDECREF(obj);
#endif
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

        Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > INT_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


SWIGINTERN size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
  const char *p;
  for (p = s; maxlen-- && *p; p++)
    ;
  return p - s;
}


SWIGINTERNINLINE PyObject * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


SWIGINTERN int
SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
{
  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    if (buf) {
      if (val) *val = new std::string(buf, size - 1);
      if (alloc == SWIG_NEWOBJ) delete[] buf;
      return SWIG_NEWOBJ;
    } else {
      if (val) *val = 0;
      return SWIG_OLDOBJ;
    }
  } else {
    static int init = 0;
    static swig_type_info* descriptor = 0;
    if (!init) {
      descriptor = SWIG_TypeQuery("std::string" " *");
      init = 1;
    }
    if (descriptor) {
      std::string *vptr;
      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
      if (SWIG_IsOK(res) && val) *val = vptr;
      return res;
    }
  }
  return SWIG_ERROR;
}


SWIGINTERNINLINE PyObject *
SWIG_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}

SWIGINTERN PyObject const *mvIMPACT_acquire_ImpactAcquireException_getArgs(mvIMPACT::acquire::ImpactAcquireException const *self){
      return Py_BuildValue("ssis",
                           self->getErrorString().c_str(),
                           self->getErrorOrigin().c_str(),
                           self->getErrorCode(),
                           self->getErrorCodeAsString().c_str());
   }
SWIGINTERN char const *mvIMPACT_acquire_ImpactAcquireException___str__(mvIMPACT::acquire::ImpactAcquireException const *self){
      return self->what();
   }

SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
  int r;
  if (!PyBool_Check(obj))
    return SWIG_ERROR;
  r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}





SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}

SWIGINTERN void mvIMPACT_acquire_PropertyS_readBinary__SWIG_3(mvIMPACT::acquire::PropertyS const *self,char *pBuf,int bufSize,int index=0,bool boLegacyMode=false){
        const std::string value = self->readBinary( index, boLegacyMode );
        const size_t bytesToCopy = ( value.size() <= static_cast<size_t>(bufSize) ) ? value.size() : static_cast<size_t>(bufSize);
        memcpy( pBuf, value.c_str(), bytesToCopy );
    }
SWIGINTERN void mvIMPACT_acquire_PropertyS_writeBinary__SWIG_2(mvIMPACT::acquire::PropertyS const *self,char const *pBuf,int bufSize,int index=0){
        const std::string value( (const char*)pBuf, (size_t)bufSize );
        self->writeBinary( value, index );
    }

SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = static_cast< char >(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}

SWIGINTERN void mvIMPACT_acquire_DeviceManager_closeAllDevices(mvIMPACT::acquire::DeviceManager *self){
        unsigned int devNr = self->deviceCount();
        while( devNr-- )
        {
            mvIMPACT::acquire::Device * const dev = self->getDevice( devNr );
            if( dev->isOpen() )
            {
                dev->close();
            }
        }
    }
SWIGINTERN mvIMPACT::acquire::Device *const mvIMPACT_acquire_DeviceManager___getitem__(mvIMPACT::acquire::DeviceManager *self,int index){
        return (*self)[index];
    }
SWIGINTERN int mvIMPACT_acquire_FunctionInterface_imageRequestSingle__SWIG_0(mvIMPACT::acquire::FunctionInterface const *self){
        return self->imageRequestSingle( 0, 0 );
    }
SWIGINTERN int mvIMPACT_acquire_FunctionInterface_imageRequestSingle__SWIG_1(mvIMPACT::acquire::FunctionInterface const *self,mvIMPACT::acquire::ImageRequestControl &imageRequestControl){
        return self->imageRequestSingle( &imageRequestControl, 0 );
    }
SWIGINTERN void mvIMPACT_acquire_DigitalOutput_setState(mvIMPACT::acquire::DigitalOutput *self,bool boState){
        if( boState )
        {
            self->set();
        }
        else
        {
            self->reset();
        }
    }

  #define SWIG_From_double   PyFloat_FromDouble 


SWIGINTERN int
SWIG_AsVal_std_string (PyObject * obj, std::string *val)
{
  std::string* v = (std::string *) 0;
  int res = SWIG_AsPtr_std_string (obj, &v);
  if (!SWIG_IsOK(res)) return res;
  if (v) {
    if (val) *val = *v;
    if (SWIG_IsNewObj(res)) {
      delete v;
      res = SWIG_DelNewMask(res);
    }
    return res;
  }
  return SWIG_ERROR;
}


namespace swig {
  template <class Type>
  struct noconst_traits {
    typedef Type noconst_type;
  };

  template <class Type>
  struct noconst_traits<const Type> {
    typedef Type noconst_type;
  };

  /*
    type categories
  */
  struct pointer_category { };
  struct value_category { };

  /*
    General traits that provides type_name and type_info
  */
  template <class Type> struct traits { };

  template <class Type>
  inline const char* type_name() {
    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
  }

  template <class Type> struct traits_info {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  /*
    Partial specialization for pointers (traits_info)
  */
  template <class Type> struct traits_info<Type *> {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  template <class Type>
  inline swig_type_info *type_info() {
    return traits_info<Type>::type_info();
  }

  /*
    Partial specialization for pointers (traits)
  */
  template <class Type> struct traits <Type *> {
    typedef pointer_category category;
    static std::string make_ptr_name(const char* name) {
      std::string ptrname = name;
      ptrname += " *";
      return ptrname;
    }
    static const char* type_name() {
      static std::string name = make_ptr_name(swig::type_name<Type>());
      return name.c_str();
    }
  };

  template <class Type, class Category>
  struct traits_as { };

  template <class Type, class Category>
  struct traits_check { };

}


namespace swig {  
  /*
    Traits that provides the from method
  */
  template <class Type> struct traits_from_ptr {
    static PyObject *from(Type *val, int owner = 0) {
      return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
    }
  };

  template <class Type> struct traits_from {
    static PyObject *from(const Type& val) {
      return traits_from_ptr<Type>::from(new Type(val), 1);
    }
  };

  template <class Type> struct traits_from<Type *> {
    static PyObject *from(Type* val) {
      return traits_from_ptr<Type>::from(val, 0);
    }
  };

  template <class Type> struct traits_from<const Type *> {
    static PyObject *from(const Type* val) {
      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
    }
  };


  template <class Type>
  inline PyObject *from(const Type& val) {
    return traits_from<Type>::from(val);
  }

  template <class Type>
  inline PyObject *from_ptr(Type* val, int owner) {
    return traits_from_ptr<Type>::from(val, owner);
  }

  /*
    Traits that provides the asval/as/check method
  */
  template <class Type>
  struct traits_asptr {   
    static int asptr(PyObject *obj, Type **val) {
      Type *p = 0;
      swig_type_info *descriptor = type_info<Type>();
      int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
      if (SWIG_IsOK(res)) {
	if (val) *val = p;
      }
      return res;
    }
  }; 

  template <class Type>
  inline int asptr(PyObject *obj, Type **vptr) {
    return traits_asptr<Type>::asptr(obj, vptr);
  }

  template <class Type> 
  struct traits_asval {
    static int asval(PyObject *obj, Type *val) {
      if (val) {
	Type *p = 0;
	int res = traits_asptr<Type>::asptr(obj, &p);
	if (!SWIG_IsOK(res)) return res;	
	if (p) {
	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
	  *(const_cast<noconst_type*>(val)) = *p;
	  if (SWIG_IsNewObj(res)){
	    delete p;
	    res = SWIG_DelNewMask(res);
	  }
	  return res;
	} else {
	  return SWIG_ERROR;
	}
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };

  template <class Type> struct traits_asval<Type*> {
    static int asval(PyObject *obj, Type **val) {
      if (val) {
        typedef typename noconst_traits<Type>::noconst_type noconst_type;
        noconst_type *p = 0;
        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
        if (SWIG_IsOK(res)) {
          *(const_cast<noconst_type**>(val)) = p;
	}
	return res;
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };
  
  template <class Type>
  inline int asval(PyObject *obj, Type *val) {
    return traits_asval<Type>::asval(obj, val);
  }

  template <class Type> 
  struct traits_as<Type, value_category> {
    static Type as(PyObject *obj) {
      Type v;
      int res = asval(obj, &v);
      if (!obj || !SWIG_IsOK(res)) {
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
      return v;
    }
  };

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(PyObject *obj) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res) && v) {
	if (SWIG_IsNewObj(res)) {
	  Type r(*v);
	  delete v;
	  return r;
	} else {
	  return *v;
	}
      } else {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };

  template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(PyObject *obj) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res)) {
	return v;
      } else {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };
    
  template <class Type>
  inline Type as(PyObject *obj) {
    return traits_as<Type, typename traits<Type>::category>::as(obj);
  }

  template <class Type> 
  struct traits_check<Type, value_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type> 
  struct traits_check<Type, pointer_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type>
  inline bool check(PyObject *obj) {
    return traits_check<Type, typename traits<Type>::category>::check(obj);
  }
}


namespace swig {
  template <> struct traits< std::string > {
    typedef value_category category;
    static const char* type_name() { return"std::string"; }
  };
  template <>  struct traits_asval< std::string > {
    typedef std::string value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_std_string (obj, val);
    }
  };
  template <>  struct traits_from< std::string > {
    typedef std::string value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_std_string  (val);
    }
  };
}


namespace swig {
  template <> struct traits< int > {
    typedef value_category category;
    static const char* type_name() { return"int"; }
  };
  template <>  struct traits_asval< int > {
    typedef int value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_int (obj, val);
    }
  };
  template <>  struct traits_from< int > {
    typedef int value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_int  (val);
    }
  };
}


  namespace swig {


















































    template <class T, class U >
    struct traits_asptr<std::pair<T,U> >  {
      typedef std::pair<T,U> value_type;

      static int get_pair(PyObject* first, PyObject* second,
			  std::pair<T,U> **val) 
      {
	if (val) {
	  value_type *vp = (new std::pair<T,U>());
	  T *pfirst = &(vp->first);
	  int res1 = swig::asval((PyObject*)first, pfirst);
	  if (!SWIG_IsOK(res1)) {
	    delete vp;
	    return res1;
	  }
	  U *psecond = &(vp->second);
	  int res2 = swig::asval((PyObject*)second, psecond);
	  if (!SWIG_IsOK(res2)) {
	    delete vp;
	    return res2;
	  }
	  *val = vp;
	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
	} else {
	  T *pfirst = 0;
	  int res1 = swig::asval((PyObject*)first, pfirst);
	  if (!SWIG_IsOK(res1)) return res1;
	  U *psecond = 0;
	  int res2 = swig::asval((PyObject*)second, psecond);
	  if (!SWIG_IsOK(res2)) return res2;
	  return res1 > res2 ? res1 : res2;
	}
      }

      static int asptr(PyObject *obj, std::pair<T,U> **val) {
	int res = SWIG_ERROR;
	if (PyTuple_Check(obj)) {
	  if (PyTuple_GET_SIZE(obj) == 2) {
	    res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
	  }
	} else if (PySequence_Check(obj)) {
	  if (PySequence_Size(obj) == 2) {
	    swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
	    swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
	    res = get_pair(first, second, val);
	  }
	} else {
	  value_type *p;
	  swig_type_info *descriptor = swig::type_info<value_type>();
	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
	  if (SWIG_IsOK(res) && val)  *val = p;
	}
	return res;
      }
    };


    template <class T, class U >
    struct traits_from<std::pair<T,U> >   {
      static PyObject *from(const std::pair<T,U>& val) {
	PyObject* obj = PyTuple_New(2);
	PyTuple_SetItem(obj,0,swig::from(val.first));
	PyTuple_SetItem(obj,1,swig::from(val.second));
	return obj;
      }
    };
  }





































      namespace swig {
	template <>  struct traits<std::pair< std::string, int > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "int" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TAcquisitionField > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TAcquisitionField"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TAcquisitionField > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TAcquisitionField" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TAcquisitionMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TAcquisitionMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TAcquisitionMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TAcquisitionMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TAcquisitionStartStopBehaviour"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TAcquisitionStartStopBehaviour" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TAoiMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TAoiMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TAoiMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TAoiMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TAutoControlSpeed > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TAutoControlSpeed"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TAutoControlSpeed > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TAutoControlSpeed" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TAutoControlMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TAutoControlMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TAutoControlMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TAutoControlMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TAutoExposureControl > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TAutoExposureControl"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TAutoExposureControl > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TAutoExposureControl" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TAutoGainControl > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TAutoGainControl"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TAutoGainControl > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TAutoGainControl" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TAutoOffsetCalibration > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TAutoOffsetCalibration"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TAutoOffsetCalibration > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TAutoOffsetCalibration" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBayerConversionMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBayerConversionMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBayerConversionMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBayerConversionMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBayerMosaicParity > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBayerMosaicParity"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBayerMosaicParity > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBayerMosaicParity" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBayerWhiteBalanceResult > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBayerWhiteBalanceResult"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBayerWhiteBalanceResult > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBayerWhiteBalanceResult" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBlueFOXDigitalInputThreshold"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBlueFOXDigitalInputThreshold" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBlueFOXFooterMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBlueFOXFooterMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBlueFOXFooterMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBlueFOXFooterMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBlueFOXSensorTiming > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBlueFOXSensorTiming"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBlueFOXSensorTiming > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBlueFOXSensorTiming" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBlueFOXTransferSize > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBlueFOXTransferSize"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBlueFOXTransferSize > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBlueFOXTransferSize" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBoolean > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBoolean"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBoolean > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBoolean" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraAoiMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraAoiMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraAoiMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraAoiMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraBinningMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraBinningMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraBinningMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraBinningMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraDataFormat > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraDataFormat"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraDataFormat > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraDataFormat" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraExposeMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraExposeMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraExposeMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraExposeMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraExternalSyncEdge > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraExternalSyncEdge"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncEdge > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraExternalSyncEdge" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraExternalSyncOutput > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraExternalSyncOutput"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncOutput > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraExternalSyncOutput" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraFlashMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraFlashMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraFlashMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraFlashMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraFlashType > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraFlashType"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraFlashType > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraFlashType" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraHDRMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraHDRMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraHDRMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraHDRMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraInterlacedType > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraInterlacedType"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraInterlacedType > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraInterlacedType" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraLinkDataValidMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraLinkDataValidMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraLinkDataValidMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraLinkDataValidMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraOutput > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraOutput"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraOutput > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraOutput" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraPixelClock > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraPixelClock"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraPixelClock > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraPixelClock" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraScanMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraScanMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraScanMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraScanMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraSerialPortBaudRate > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraSerialPortBaudRate"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraSerialPortBaudRate > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraSerialPortBaudRate" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraShutterMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraShutterMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraShutterMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraShutterMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraTapsXGeometry > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraTapsXGeometry"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraTapsXGeometry > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraTapsXGeometry" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraTapsYGeometry > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraTapsYGeometry"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraTapsYGeometry > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraTapsYGeometry" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraTestMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraTestMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraTestMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraTestMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraTriggerMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraTriggerMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraTriggerMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraTriggerMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TCameraTriggerSource > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TCameraTriggerSource"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TCameraTriggerSource > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TCameraTriggerSource" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TChannelSplitMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TChannelSplitMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TChannelSplitMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TChannelSplitMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TClampMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TClampMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TClampMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TClampMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TColorProcessingMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TColorProcessingMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TColorProcessingMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TColorProcessingMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDarkCurrentFilterMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDarkCurrentFilterMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDarkCurrentFilterMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDarkCurrentFilterMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDefectivePixelsFilterMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDefectivePixelsFilterMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDefectivePixelsFilterMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDefectivePixelsFilterMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceAccessMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceAccessMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceAccessMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceAccessMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceAdvancedOptions > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceAdvancedOptions"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceAdvancedOptions > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceAdvancedOptions" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceCapability > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceCapability"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceCapability > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceCapability" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceClass > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceClass"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceClass > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceClass" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceDigitalOutputMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceDigitalOutputMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceDigitalOutputMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceDigitalOutputMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceImageTrigger > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceImageTrigger"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceImageTrigger > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceImageTrigger" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceInterfaceLayout > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceInterfaceLayout"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceInterfaceLayout > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceInterfaceLayout" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceLoadSettings > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceLoadSettings"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceLoadSettings > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceLoadSettings" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDevicePowerMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDevicePowerMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDevicePowerMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDevicePowerMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceScanRateMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceScanRateMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceScanRateMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceScanRateMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceSignalOutputStartEvent"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceSignalOutputStartEvent" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceState > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceState"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceState > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceState" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceSyncOutMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceSyncOutMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceSyncOutMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceSyncOutMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceTriggerInterface > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceTriggerInterface"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerInterface > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceTriggerInterface" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceTriggerMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceTriggerMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceTriggerMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDigIOState > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDigIOState"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDigIOState > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDigIOState" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDigitalIOMeasurementMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDigitalIOMeasurementMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDigitalIOMeasurementMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDigitalIOMeasurementSource > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDigitalIOMeasurementSource"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementSource > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDigitalIOMeasurementSource" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDigitalOutputControlMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDigitalOutputControlMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDigitalOutputControlMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDigitalOutputControlMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDigitalSignal > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDigitalSignal"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDigitalSignal > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDigitalSignal" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TFieldGateMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TFieldGateMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TFieldGateMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TFieldGateMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TFlatFieldFilterCorrectionMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TFlatFieldFilterCorrectionMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TFlatFieldFilterMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TFlatFieldFilterMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TFlatFieldFilterMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::THWUpdateResult > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::THWUpdateResult"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::THWUpdateResult > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::THWUpdateResult" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TI2COperationMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TI2COperationMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TI2COperationMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TI2COperationMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TI2COperationStatus > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TI2COperationStatus"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TI2COperationStatus > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TI2COperationStatus" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TImageBufferPixelFormat > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TImageBufferPixelFormat"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TImageBufferPixelFormat > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TImageBufferPixelFormat" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TImageBufferFormatReinterpreterMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TImageBufferFormatReinterpreterMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TImageDestinationPixelFormat > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TImageDestinationPixelFormat"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TImageDestinationPixelFormat > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TImageDestinationPixelFormat" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TImageProcessingFilter > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TImageProcessingFilter"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TImageProcessingFilter > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TImageProcessingFilter" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TImageProcessingMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TImageProcessingMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TImageProcessingMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TImageProcessingMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TImageProcessingOptimization > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TImageProcessingOptimization"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TImageProcessingOptimization > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TImageProcessingOptimization" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TImageProcessingResult > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TImageProcessingResult"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TImageProcessingResult > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TImageProcessingResult" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TRequestImageMemoryMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TRequestImageMemoryMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TRequestImageMemoryMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TRequestImageMemoryMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TImageRequestControlMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TImageRequestControlMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TImageRequestControlMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TImageRequestControlMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TInfoSensorColorMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TInfoSensorColorMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TInfoSensorColorMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TInfoSensorColorMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TInfoSensorType > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TInfoSensorType"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TInfoSensorType > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TInfoSensorType" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TInterfaceEnumerationBehaviour"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TInterfaceEnumerationBehaviour" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TInterlacedMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TInterlacedMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TInterlacedMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TInterlacedMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TLineCounter > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TLineCounter"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TLineCounter > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TLineCounter" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TLUTGammaMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TLUTGammaMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TLUTGammaMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TLUTGammaMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TLUTImplementation > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TLUTImplementation"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TLUTImplementation > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TLUTImplementation" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TLUTInterpolationMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TLUTInterpolationMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TLUTInterpolationMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TLUTInterpolationMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TLUTMapping > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TLUTMapping"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TLUTMapping > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TLUTMapping" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TLUTMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TLUTMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TLUTMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TLUTMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TMemoryManagerMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TMemoryManagerMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TMemoryManagerMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TMemoryManagerMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TMemoryManagerPoolMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TMemoryManagerPoolMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TMemoryManagerPoolMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TMemoryManagerPoolMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TMirrorMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TMirrorMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TMirrorMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TMirrorMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TMirrorOperationMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TMirrorOperationMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TMirrorOperationMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TMirrorOperationMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TOnBoardMemoryMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TOnBoardMemoryMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TOnBoardMemoryMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TOnBoardMemoryMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TPolarizedDataExtractionMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TPolarizedDataExtractionMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TPolarizedDataExtractionMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TPulseStartTrigger > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TPulseStartTrigger"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TPulseStartTrigger > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TPulseStartTrigger" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TRequestResult > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TRequestResult"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TRequestResult > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TRequestResult" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TRequestState > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TRequestState"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TRequestState > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TRequestState" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TRTCtrlModes > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TRTCtrlModes"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TRTCtrlModes > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TRTCtrlModes" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TRTProgOpCodes > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TRTProgOpCodes"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TRTProgOpCodes > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TRTProgOpCodes" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TScalerMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TScalerMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TScalerMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TScalerMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TScalerInterpolationMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TScalerInterpolationMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TScalerInterpolationMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TScalerInterpolationMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TScanClock > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TScanClock"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TScanClock > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TScanClock" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TScanStandard > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TScanStandard"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TScanStandard > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TScanStandard" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TTriggerMoment > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TTriggerMoment"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TTriggerMoment > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TTriggerMoment" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TUserDataAccessRight > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TUserDataAccessRight"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TUserDataAccessRight > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TUserDataAccessRight" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TUserDataReconnectBehaviour > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TUserDataReconnectBehaviour"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TUserDataReconnectBehaviour > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TUserDataReconnectBehaviour" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TVideoStandard > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TVideoStandard"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TVideoStandard > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TVideoStandard" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TVirtualDeviceImageType > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TVirtualDeviceImageType"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceImageType > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TVirtualDeviceImageType" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TVirtualDeviceTestMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TVirtualDeviceTestMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceTestMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TVirtualDeviceTestMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TWhiteBalanceCalibrationMode"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TWhiteBalanceCalibrationMode" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TWhiteBalanceParameter > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TWhiteBalanceParameter"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceParameter > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TWhiteBalanceParameter" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::int64_type > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::int64_type"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::int64_type > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::int64_type" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TBufferPartDataType > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TBufferPartDataType"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TBufferPartDataType > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TBufferPartDataType" " >";
	  }
	};
      }
    

  namespace swig {
    template <>  struct traits< mvIMPACT::acquire::TDeviceTriggerOverlap > {
      typedef pointer_category category;
      static const char* type_name() { return"mvIMPACT::acquire::TDeviceTriggerOverlap"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerOverlap > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "mvIMPACT::acquire::TDeviceTriggerOverlap" " >";
	  }
	};
      }
    

namespace swig {
  template <> struct traits< double > {
    typedef value_category category;
    static const char* type_name() { return"double"; }
  };
  template <>  struct traits_asval< double > {
    typedef double value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_double (obj, val);
    }
  };
  template <>  struct traits_from< double > {
    typedef double value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_double  (val);
    }
  };
}


      namespace swig {
	template <>  struct traits<std::pair< std::string, double > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "std::string" "," "double" " >";
	  }
	};
      }
    


/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "acquire_wrap.h"

SwigDirector_ComponentCallback::SwigDirector_ComponentCallback(PyObject *self, void *pUserData): mvIMPACT::acquire::ComponentCallback(pUserData), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((mvIMPACT::acquire::ComponentCallback *)this, this);  }
SwigDirector_ComponentCallback::SwigDirector_ComponentCallback(PyObject *self, mvIMPACT::acquire::ComponentCallback const &src): mvIMPACT::acquire::ComponentCallback(src), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((mvIMPACT::acquire::ComponentCallback *)this, this);  }
SwigDirector_ComponentCallback::~SwigDirector_ComponentCallback() {
}

void SwigDirector_ComponentCallback::execute(mvIMPACT::acquire::Component &c, void *pUserData) { SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&c), SWIGTYPE_p_mvIMPACT__acquire__Component,  0 );
    swig::SwigVar_PyObject obj1; obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(pUserData), SWIGTYPE_p_void,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ComponentCallback.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 0; const char *const swig_method_name = "execute";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("execute");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'ComponentCallback.execute'"); }  }  } 
  SWIG_PYTHON_THREAD_END_BLOCK; }
SwigDirector_Request::SwigDirector_Request(PyObject *self, mvIMPACT::acquire::Device *pDev, int requestNr): mvIMPACT::acquire::Request(pDev, requestNr), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((mvIMPACT::acquire::Request *)this, this);  }
SwigDirector_Request::SwigDirector_Request(PyObject *self, mvIMPACT::acquire::Request const &src): mvIMPACT::acquire::Request(src), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((mvIMPACT::acquire::Request *)this, this);  }
SwigDirector_Request::~SwigDirector_Request() {
}

SwigDirector_RequestFactory::SwigDirector_RequestFactory(PyObject *self): mvIMPACT::acquire::RequestFactory(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((mvIMPACT::acquire::RequestFactory *)this, this);  }
SwigDirector_RequestFactory::~SwigDirector_RequestFactory() {
}

mvIMPACT::acquire::Request *SwigDirector_RequestFactory::createRequest(mvIMPACT::acquire::Device *arg0, int arg1) {
  mvIMPACT::acquire::Request *c_result = 0 ; void *swig_argp ; int swig_res ; swig_owntype own ; SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_mvIMPACT__acquire__Device,  0 );
    swig::SwigVar_PyObject obj1; obj1 = SWIG_From_int(static_cast< int >(arg1)); if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call RequestFactory.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 0; const char *const swig_method_name = "createRequest";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("createRequest");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'RequestFactory.createRequest'"); }  } 
    swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mvIMPACT__acquire__Request,  0  | SWIG_POINTER_DISOWN, &own);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mvIMPACT::acquire::Request *""'"); }
     c_result = reinterpret_cast< mvIMPACT::acquire::Request * >(swig_argp);
    swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own ); }  SWIG_PYTHON_THREAD_END_BLOCK;
  return (mvIMPACT::acquire::Request *) c_result; }
SwigDirector_FirmwareUpdater::SwigDirector_FirmwareUpdater(PyObject *self, mvIMPACT::acquire::Device *pDev, bool boForceOverideSameVersion, bool boForceDowngrade, bool boKeepUserSets, bool boForceBreakingChange): mvIMPACT::acquire::FirmwareUpdater(pDev, boForceOverideSameVersion, boForceDowngrade, boKeepUserSets, boForceBreakingChange), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((mvIMPACT::acquire::FirmwareUpdater *)this, this);  }
SwigDirector_FirmwareUpdater::~SwigDirector_FirmwareUpdater() {
}

int SwigDirector_FirmwareUpdater::onErrorMessage(double const timeElapsed_s) const { int c_result = SwigValueInit< int >() ;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; { swig::SwigVar_PyObject obj0; obj0 = SWIG_From_double(static_cast< double >(timeElapsed_s));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FirmwareUpdater.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 0; const char *const swig_method_name = "onErrorMessage";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onErrorMessage");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'FirmwareUpdater.onErrorMessage'"); }  } 
    int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); }
     c_result = static_cast< int >(swig_val); }  SWIG_PYTHON_THREAD_END_BLOCK; return (int) c_result; }
int SwigDirector_FirmwareUpdater::onErasingFlash(int const currentProgress_pc, double const timeElapsed_s) const {
  int c_result = SwigValueInit< int >() ; SWIG_PYTHON_THREAD_BEGIN_BLOCK; { swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_int(static_cast< int >(currentProgress_pc)); swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(timeElapsed_s)); if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FirmwareUpdater.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 1; const char *const swig_method_name = "onErasingFlash";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onErasingFlash");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'FirmwareUpdater.onErasingFlash'"); }  } 
    int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); }
     c_result = static_cast< int >(swig_val); }  SWIG_PYTHON_THREAD_END_BLOCK; return (int) c_result; }
int SwigDirector_FirmwareUpdater::onUnzippingFirmwareArchive(int const currentProgress_pc, double const timeElapsed_s) const {
  int c_result = SwigValueInit< int >() ; SWIG_PYTHON_THREAD_BEGIN_BLOCK; { swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_int(static_cast< int >(currentProgress_pc)); swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(timeElapsed_s)); if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FirmwareUpdater.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 2; const char *const swig_method_name = "onUnzippingFirmwareArchive";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onUnzippingFirmwareArchive");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'FirmwareUpdater.onUnzippingFirmwareArchive'"); }  } 
    int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); }
     c_result = static_cast< int >(swig_val); }  SWIG_PYTHON_THREAD_END_BLOCK; return (int) c_result; }
int SwigDirector_FirmwareUpdater::onUpdatingBootProgrammer(int const currentProgress_pc, double const timeElapsed_s) const {
  int c_result = SwigValueInit< int >() ; SWIG_PYTHON_THREAD_BEGIN_BLOCK; { swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_int(static_cast< int >(currentProgress_pc)); swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(timeElapsed_s)); if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FirmwareUpdater.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 3; const char *const swig_method_name = "onUpdatingBootProgrammer";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onUpdatingBootProgrammer");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'FirmwareUpdater.onUpdatingBootProgrammer'"); }  } 
    int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); }
     c_result = static_cast< int >(swig_val); }  SWIG_PYTHON_THREAD_END_BLOCK; return (int) c_result; }
int SwigDirector_FirmwareUpdater::onUploadingImage(int const currentProgress_pc, double const timeElapsed_s) const {
  int c_result = SwigValueInit< int >() ; SWIG_PYTHON_THREAD_BEGIN_BLOCK; { swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_int(static_cast< int >(currentProgress_pc)); swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(timeElapsed_s)); if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FirmwareUpdater.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 4; const char *const swig_method_name = "onUploadingImage";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onUploadingImage");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'FirmwareUpdater.onUploadingImage'"); }  } 
    int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); }
     c_result = static_cast< int >(swig_val); }  SWIG_PYTHON_THREAD_END_BLOCK; return (int) c_result; }
int SwigDirector_FirmwareUpdater::onRebooting(int const currentProgress_pc, double const timeElapsed_s) const {
  int c_result = SwigValueInit< int >() ; SWIG_PYTHON_THREAD_BEGIN_BLOCK; { swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_int(static_cast< int >(currentProgress_pc)); swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(timeElapsed_s)); if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FirmwareUpdater.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 5; const char *const swig_method_name = "onRebooting";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onRebooting");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'FirmwareUpdater.onRebooting'"); }  }  int swig_val;
    int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); }
     c_result = static_cast< int >(swig_val); }  SWIG_PYTHON_THREAD_END_BLOCK; return (int) c_result; }
int SwigDirector_FirmwareUpdater::onHardResetRequired(int const currentProgress_pc, double const timeElapsed_s) const {
  int c_result = SwigValueInit< int >() ; SWIG_PYTHON_THREAD_BEGIN_BLOCK; { swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_int(static_cast< int >(currentProgress_pc)); swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(timeElapsed_s)); if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FirmwareUpdater.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 6; const char *const swig_method_name = "onHardResetRequired";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onHardResetRequired");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'FirmwareUpdater.onHardResetRequired'"); }  } 
    int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); }
     c_result = static_cast< int >(swig_val); }  SWIG_PYTHON_THREAD_END_BLOCK; return (int) c_result; }
int SwigDirector_FirmwareUpdater::onSavingUserSets(int const currentProgress_pc, double const timeElapsed_s) const {
  int c_result = SwigValueInit< int >() ; SWIG_PYTHON_THREAD_BEGIN_BLOCK; { swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_int(static_cast< int >(currentProgress_pc)); swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(timeElapsed_s)); if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FirmwareUpdater.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 7; const char *const swig_method_name = "onSavingUserSets";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onSavingUserSets");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'FirmwareUpdater.onSavingUserSets'"); }  } 
    int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); }
     c_result = static_cast< int >(swig_val); }  SWIG_PYTHON_THREAD_END_BLOCK; return (int) c_result; }
int SwigDirector_FirmwareUpdater::onLoadingUserSets(int const currentProgress_pc, double const timeElapsed_s) const {
  int c_result = SwigValueInit< int >() ; SWIG_PYTHON_THREAD_BEGIN_BLOCK; { swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_int(static_cast< int >(currentProgress_pc)); swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(timeElapsed_s)); if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FirmwareUpdater.__init__."); }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
     const size_t swig_method_index = 8; const char *const swig_method_name = "onLoadingUserSets";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
     swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onLoadingUserSets");swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
     if (!result) { PyObject *error = PyErr_Occurred(); if (error) {
        Swig::DirectorMethodException::raise("Error detected when calling 'FirmwareUpdater.onLoadingUserSets'"); }  } 
    int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); }
     c_result = static_cast< int >(swig_val); }  SWIG_PYTHON_THREAD_END_BLOCK; return (int) c_result; }
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  PyObject *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value(); SWIG_PYTHON_THREAD_END_ALLOW; } }
   catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = result; return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; size_t arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; swig::SwigPyIterator *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'"); }
    arg2 = static_cast< size_t >(val2); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->incr(arg2); SWIG_PYTHON_THREAD_END_ALLOW; } }  catch(swig::stop_iteration &_e) {
    { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->incr(); SWIG_PYTHON_THREAD_END_ALLOW; } }  catch(swig::stop_iteration &_e) { {
      (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_incr", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
  "  Possible C/C++ prototypes are:\n" "    swig::SwigPyIterator::incr(size_t)\n" "    swig::SwigPyIterator::incr()\n");
  return 0; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; size_t arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; swig::SwigPyIterator *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'"); }
    arg2 = static_cast< size_t >(val2); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->decr(arg2); SWIG_PYTHON_THREAD_END_ALLOW; } }  catch(swig::stop_iteration &_e) {
    { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->decr(); SWIG_PYTHON_THREAD_END_ALLOW; } }  catch(swig::stop_iteration &_e) { {
      (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
  "  Possible C/C++ prototypes are:\n" "    swig::SwigPyIterator::decr(size_t)\n" "    swig::SwigPyIterator::decr()\n");
  return 0; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; ptrdiff_t result;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); }
   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW; } }  catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; }
   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); }
   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW; } }  catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; }
   resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy(); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  PyObject *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (PyObject *)(arg1)->next(); SWIG_PYTHON_THREAD_END_ALLOW; } }  catch(swig::stop_iteration &_e) { { (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  }  resultobj = result; return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  PyObject *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (PyObject *)(arg1)->__next__(); SWIG_PYTHON_THREAD_END_ALLOW; } }  catch(swig::stop_iteration &_e) { { (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  }  resultobj = result; return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  PyObject *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (PyObject *)(arg1)->previous(); SWIG_PYTHON_THREAD_END_ALLOW; } }  catch(swig::stop_iteration &_e) { { (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  }  resultobj = result; return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ;
  int ecode2 = 0 ; PyObject *swig_obj[2] ; swig::SwigPyIterator *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'"); }
    arg2 = static_cast< ptrdiff_t >(val2); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->advance(arg2); SWIG_PYTHON_THREAD_END_ALLOW; } }
   catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); }
   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail:
  PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; }
SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); }
   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail:
  PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; }
SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ;
  int ecode2 = 0 ; PyObject *swig_obj[2] ; swig::SwigPyIterator *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'"); }
    arg2 = static_cast< ptrdiff_t >(val2); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2); SWIG_PYTHON_THREAD_END_ALLOW; } }
   catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ;
  int ecode2 = 0 ; PyObject *swig_obj[2] ; swig::SwigPyIterator *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'"); }
    arg2 = static_cast< ptrdiff_t >(val2); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2); SWIG_PYTHON_THREAD_END_ALLOW; } }
   catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ;
  int ecode2 = 0 ; PyObject *swig_obj[2] ; swig::SwigPyIterator *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'"); }
    arg2 = static_cast< ptrdiff_t >(val2); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2); SWIG_PYTHON_THREAD_END_ALLOW; } }
   catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; }
SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; swig::SwigPyIterator *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'"); }
    arg2 = static_cast< ptrdiff_t >(val2); try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2); SWIG_PYTHON_THREAD_END_ALLOW; } }
   catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; }
SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; ptrdiff_t result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");  }
   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); }
   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); return resultobj; fail:
  PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; }
SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);} 
  check_1: if (argc == 2) { PyObject *retobj = _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail: Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented; }
SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_INVALID_ID_set(PyObject *) { SWIG_Error(SWIG_AttributeError,"Variable INVALID_ID is read-only.");
  return 1; }
SWIGINTERN PyObject *Swig_var_INVALID_ID_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_int(static_cast< int >(mvIMPACT::acquire::INVALID_ID)); return pyobj; }
SWIGINTERN int Swig_var_ROOT_LIST_set(PyObject *) { SWIG_Error(SWIG_AttributeError,"Variable ROOT_LIST is read-only.");
  return 1; }
SWIGINTERN PyObject *Swig_var_ROOT_LIST_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ROOT_LIST)); return pyobj; }
SWIGINTERN int Swig_var_END_OF_LIST_set(PyObject *) { SWIG_Error(SWIG_AttributeError,"Variable END_OF_LIST is read-only.");
  return 1; }
SWIGINTERN PyObject *Swig_var_END_OF_LIST_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_int(static_cast< int >(mvIMPACT::acquire::END_OF_LIST)); return pyobj; }
SWIGINTERN int Swig_var_smIgnoreLists_set(PyObject *) { SWIG_Error(SWIG_AttributeError,"Variable smIgnoreLists is read-only.");
  return 1; }
SWIGINTERN PyObject *Swig_var_smIgnoreLists_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(mvIMPACT::acquire::smIgnoreLists)); return pyobj; }
SWIGINTERN int Swig_var_smIgnoreMethods_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable smIgnoreMethods is read-only."); return 1; }
SWIGINTERN PyObject *Swig_var_smIgnoreMethods_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(mvIMPACT::acquire::smIgnoreMethods)); return pyobj; }
SWIGINTERN int Swig_var_smIgnoreProperties_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable smIgnoreProperties is read-only."); return 1; }
SWIGINTERN PyObject *Swig_var_smIgnoreProperties_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(mvIMPACT::acquire::smIgnoreProperties)); return pyobj; }
SWIGINTERN PyObject *_wrap_ChannelData_iChannelOffset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ChannelData *arg1 = (mvIMPACT::acquire::ChannelData *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ChannelData_iChannelOffset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChannelData_iChannelOffset_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChannelData_iChannelOffset_set" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->iChannelOffset = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChannelData_iChannelOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ChannelData *arg1 = (mvIMPACT::acquire::ChannelData *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChannelData_iChannelOffset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->iChannelOffset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChannelData_iLinePitch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ChannelData *arg1 = (mvIMPACT::acquire::ChannelData *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ChannelData_iLinePitch_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChannelData_iLinePitch_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChannelData_iLinePitch_set" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->iLinePitch = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChannelData_iLinePitch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ChannelData *arg1 = (mvIMPACT::acquire::ChannelData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChannelData_iLinePitch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->iLinePitch); SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChannelData_iPixelPitch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ChannelData *arg1 = (mvIMPACT::acquire::ChannelData *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ChannelData_iPixelPitch_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChannelData_iPixelPitch_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChannelData_iPixelPitch_set" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->iPixelPitch = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChannelData_iPixelPitch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ChannelData *arg1 = (mvIMPACT::acquire::ChannelData *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChannelData_iPixelPitch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->iPixelPitch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChannelData_szChannelDesc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ChannelData *arg1 = (mvIMPACT::acquire::ChannelData *) 0 ; char *arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; char temp2[DEFAULT_STRING_SIZE_LIMIT] ; int res2 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ChannelData_szChannelDesc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChannelData_szChannelDesc_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp1);
  res2 = SWIG_AsCharArray(swig_obj[1], temp2, DEFAULT_STRING_SIZE_LIMIT); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChannelData_szChannelDesc_set" "', argument " "2"" of type '" "char [DEFAULT_STRING_SIZE_LIMIT]""'"); }
   arg2 = reinterpret_cast< char * >(temp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg2) memcpy(arg1->szChannelDesc,arg2,DEFAULT_STRING_SIZE_LIMIT*sizeof(char));
    else memset(arg1->szChannelDesc,0,DEFAULT_STRING_SIZE_LIMIT*sizeof(char)); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChannelData_szChannelDesc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ChannelData *arg1 = (mvIMPACT::acquire::ChannelData *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; char *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChannelData_szChannelDesc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(char *) ((arg1)->szChannelDesc); SWIG_PYTHON_THREAD_END_ALLOW; }  {
    size_t size = SWIG_strnlen(result, DEFAULT_STRING_SIZE_LIMIT); resultobj = SWIG_FromCharPtrAndSize(result, size); } 
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ChannelData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ChannelData *result = 0 ; if (!SWIG_Python_UnpackTuple(args, "new_ChannelData", 0, 0, 0)) SWIG_fail; {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::ChannelData *)new mvIMPACT::acquire::ChannelData();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ChannelData, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ChannelData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ChannelData *arg1 = (mvIMPACT::acquire::ChannelData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChannelData" "', argument " "1"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ChannelData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ChannelData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ChannelData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ImageBuffer_iBytesPerPixel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ImageBuffer_iBytesPerPixel_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iBytesPerPixel_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageBuffer_iBytesPerPixel_set" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->iBytesPerPixel = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_iBytesPerPixel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iBytesPerPixel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->iBytesPerPixel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_iHeight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ImageBuffer_iHeight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iHeight_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageBuffer_iHeight_set" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->iHeight = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_iHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->iHeight); SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_iWidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ImageBuffer_iWidth_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iWidth_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageBuffer_iWidth_set" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->iWidth = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_iWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->iWidth); SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_pixelFormat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ;
  mvIMPACT::acquire::TImageBufferPixelFormat arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ; if (!SWIG_Python_UnpackTuple(args, "ImageBuffer_pixelFormat_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_pixelFormat_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageBuffer_pixelFormat_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageBufferPixelFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageBufferPixelFormat >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->pixelFormat = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_pixelFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageBufferPixelFormat result; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_pixelFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::TImageBufferPixelFormat) ((arg1)->pixelFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_iSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ImageBuffer_iSize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iSize_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageBuffer_iSize_set" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->iSize = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_iSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->iSize); SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_vpData_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *arg2 = (void *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; int res2 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ImageBuffer_vpData_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_vpData_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageBuffer_vpData_set" "', argument " "2"" of type '" "void *""'");  }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->vpData = arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_vpData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; void *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_vpData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (void *) ((arg1)->vpData); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 ); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_iChannelCount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ImageBuffer_iChannelCount_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iChannelCount_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageBuffer_iChannelCount_set" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->iChannelCount = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_iChannelCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_iChannelCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->iChannelCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_pChannels_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ;
  mvIMPACT::acquire::ChannelData *arg2 = (mvIMPACT::acquire::ChannelData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ImageBuffer_pChannels_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_pChannels_set" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__ChannelData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageBuffer_pChannels_set" "', argument " "2"" of type '" "mvIMPACT::acquire::ChannelData *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ChannelData * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->pChannels = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_ImageBuffer_pChannels_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::ChannelData *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBuffer_pChannels_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::ChannelData *) ((arg1)->pChannels); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ChannelData, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *result = 0 ; if (!SWIG_Python_UnpackTuple(args, "new_ImageBuffer", 0, 0, 0)) SWIG_fail; {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::ImageBuffer *)new mvIMPACT::acquire::ImageBuffer();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ImageBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBuffer *arg1 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageBuffer" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBuffer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ImageBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImageBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ImpactAcquireException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; std::string *arg2 = 0 ; int arg3 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ; int val3 ;
  int ecode3 = 0 ; PyObject *swig_obj[3] ; mvIMPACT::acquire::ImpactAcquireException *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "new_ImpactAcquireException", 3, 3, swig_obj)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImpactAcquireException" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImpactAcquireException" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ImpactAcquireException" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImpactAcquireException" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImpactAcquireException" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImpactAcquireException *)new mvIMPACT::acquire::ImpactAcquireException((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_delete_ImpactAcquireException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImpactAcquireException *arg1 = (mvIMPACT::acquire::ImpactAcquireException *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImpactAcquireException" "', argument " "1"" of type '" "mvIMPACT::acquire::ImpactAcquireException *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImpactAcquireException * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException_getErrorString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImpactAcquireException *arg1 = (mvIMPACT::acquire::ImpactAcquireException *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactAcquireException_getErrorString" "', argument " "1"" of type '" "mvIMPACT::acquire::ImpactAcquireException const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImpactAcquireException * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::ImpactAcquireException const *)arg1)->getErrorString(); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException_getErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImpactAcquireException *arg1 = (mvIMPACT::acquire::ImpactAcquireException *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactAcquireException_getErrorCode" "', argument " "1"" of type '" "mvIMPACT::acquire::ImpactAcquireException const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImpactAcquireException * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::ImpactAcquireException const *)arg1)->getErrorCode(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException_getErrorCodeAsString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImpactAcquireException *arg1 = (mvIMPACT::acquire::ImpactAcquireException *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactAcquireException_getErrorCodeAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::ImpactAcquireException const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImpactAcquireException * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::ImpactAcquireException const *)arg1)->getErrorCodeAsString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException_getErrorCodeAsString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; int arg1 ; int val1 ; int ecode1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImpactAcquireException_getErrorCodeAsString" "', argument " "1"" of type '" "int""'"); }
    arg1 = static_cast< int >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = mvIMPACT::acquire::ImpactAcquireException::getErrorCodeAsString(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException_getErrorCodeAsString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImpactAcquireException_getErrorCodeAsString", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 1) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1;
    return _wrap_ImpactAcquireException_getErrorCodeAsString__SWIG_0(self, argc, argv);}  check_1: if (argc == 1) {
    PyObject *retobj = _wrap_ImpactAcquireException_getErrorCodeAsString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImpactAcquireException_getErrorCodeAsString'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ImpactAcquireException::getErrorCodeAsString() const\n"
  "    mvIMPACT::acquire::ImpactAcquireException::getErrorCodeAsString(int)\n"); return 0; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException_getErrorOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImpactAcquireException *arg1 = (mvIMPACT::acquire::ImpactAcquireException *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactAcquireException_getErrorOrigin" "', argument " "1"" of type '" "mvIMPACT::acquire::ImpactAcquireException const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImpactAcquireException * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::ImpactAcquireException const *)arg1)->getErrorOrigin(); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException_getArgs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImpactAcquireException *arg1 = (mvIMPACT::acquire::ImpactAcquireException *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; PyObject *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactAcquireException_getArgs" "', argument " "1"" of type '" "mvIMPACT::acquire::ImpactAcquireException const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImpactAcquireException * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (PyObject *)mvIMPACT_acquire_ImpactAcquireException_getArgs((mvIMPACT::acquire::ImpactAcquireException const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = result; return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImpactAcquireException *arg1 = (mvIMPACT::acquire::ImpactAcquireException *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; char *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactAcquireException___str__" "', argument " "1"" of type '" "mvIMPACT::acquire::ImpactAcquireException const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImpactAcquireException * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (char *)mvIMPACT_acquire_ImpactAcquireException___str__((mvIMPACT::acquire::ImpactAcquireException const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_FromCharPtr((const char *)result); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ImpactAcquireException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImpactAcquireException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EDeviceManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; std::string *arg2 = 0 ; mvIMPACT::acquire::TDMR_ERROR arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ; PyObject *swig_obj[3] ; mvIMPACT::acquire::EDeviceManager *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "new_EDeviceManager", 3, 3, swig_obj)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EDeviceManager" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EDeviceManager" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EDeviceManager" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EDeviceManager" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EDeviceManager" "', argument " "3"" of type '" "mvIMPACT::acquire::TDMR_ERROR""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDMR_ERROR >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EDeviceManager *)new mvIMPACT::acquire::EDeviceManager((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EDeviceManager, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_delete_EDeviceManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EDeviceManager *arg1 = (mvIMPACT::acquire::EDeviceManager *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EDeviceManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EDeviceManager" "', argument " "1"" of type '" "mvIMPACT::acquire::EDeviceManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EDeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EDeviceManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EDeviceManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EDeviceManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EPropertyHandling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; std::string *arg2 = 0 ; mvIMPACT::acquire::TPROPHANDLING_ERROR arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ; PyObject *swig_obj[3] ;
  mvIMPACT::acquire::EPropertyHandling *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "new_EPropertyHandling", 3, 3, swig_obj)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EPropertyHandling" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EPropertyHandling" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EPropertyHandling" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EPropertyHandling" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EPropertyHandling" "', argument " "3"" of type '" "mvIMPACT::acquire::TPROPHANDLING_ERROR""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TPROPHANDLING_ERROR >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EPropertyHandling *)new mvIMPACT::acquire::EPropertyHandling((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EPropertyHandling, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_delete_EPropertyHandling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EPropertyHandling *arg1 = (mvIMPACT::acquire::EPropertyHandling *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EPropertyHandling, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EPropertyHandling" "', argument " "1"" of type '" "mvIMPACT::acquire::EPropertyHandling *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EPropertyHandling * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EPropertyHandling_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EPropertyHandling, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EPropertyHandling_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *EComponent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EComponent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ENotAList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ENotAList *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENotAList" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAList" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENotAList" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAList" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ENotAList" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENotAList *)new mvIMPACT::acquire::ENotAList((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENotAList, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENotAList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ENotAList *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENotAList" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAList" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENotAList" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAList" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENotAList *)new mvIMPACT::acquire::ENotAList((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENotAList, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENotAList(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ENotAList", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_ENotAList__SWIG_1(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 3) { PyObject *retobj = _wrap_new_ENotAList__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ENotAList'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ENotAList::ENotAList(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ENotAList::ENotAList(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ENotAList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ENotAList *arg1 = (mvIMPACT::acquire::ENotAList *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ENotAList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ENotAList" "', argument " "1"" of type '" "mvIMPACT::acquire::ENotAList *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ENotAList * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ENotAList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ENotAList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ENotAList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ENotAProperty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ENotAProperty *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENotAProperty" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAProperty" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENotAProperty" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAProperty" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ENotAProperty" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENotAProperty *)new mvIMPACT::acquire::ENotAProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENotAProperty, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENotAProperty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ENotAProperty *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENotAProperty" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAProperty" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENotAProperty" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAProperty" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENotAProperty *)new mvIMPACT::acquire::ENotAProperty((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENotAProperty, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENotAProperty(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ENotAProperty", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_ENotAProperty__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ENotAProperty__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ENotAProperty'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ENotAProperty::ENotAProperty(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ENotAProperty::ENotAProperty(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ENotAProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ENotAProperty *arg1 = (mvIMPACT::acquire::ENotAProperty *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ENotAProperty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ENotAProperty" "', argument " "1"" of type '" "mvIMPACT::acquire::ENotAProperty *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ENotAProperty * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ENotAProperty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ENotAProperty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ENotAProperty_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ENotAMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ENotAMethod *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENotAMethod" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAMethod" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENotAMethod" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAMethod" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ENotAMethod" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENotAMethod *)new mvIMPACT::acquire::ENotAMethod((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENotAMethod, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENotAMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ENotAMethod *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENotAMethod" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAMethod" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENotAMethod" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENotAMethod" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENotAMethod *)new mvIMPACT::acquire::ENotAMethod((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENotAMethod, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENotAMethod(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ENotAMethod", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_ENotAMethod__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ENotAMethod__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ENotAMethod'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ENotAMethod::ENotAMethod(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ENotAMethod::ENotAMethod(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ENotAMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ENotAMethod *arg1 = (mvIMPACT::acquire::ENotAMethod *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ENotAMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ENotAMethod" "', argument " "1"" of type '" "mvIMPACT::acquire::ENotAMethod *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ENotAMethod * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ENotAMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ENotAMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ENotAMethod_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ENoReadRights__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ENoReadRights *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENoReadRights" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoReadRights" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENoReadRights" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoReadRights" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ENoReadRights" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENoReadRights *)new mvIMPACT::acquire::ENoReadRights((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENoReadRights, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENoReadRights__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ENoReadRights *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENoReadRights" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoReadRights" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENoReadRights" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoReadRights" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENoReadRights *)new mvIMPACT::acquire::ENoReadRights((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENoReadRights, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENoReadRights(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ENoReadRights", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_ENoReadRights__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ENoReadRights__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ENoReadRights'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ENoReadRights::ENoReadRights(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ENoReadRights::ENoReadRights(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ENoReadRights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ENoReadRights *arg1 = (mvIMPACT::acquire::ENoReadRights *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ENoReadRights, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ENoReadRights" "', argument " "1"" of type '" "mvIMPACT::acquire::ENoReadRights *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ENoReadRights * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ENoReadRights_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ENoReadRights, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ENoReadRights_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ENoWriteRights__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ENoWriteRights *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENoWriteRights" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoWriteRights" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENoWriteRights" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoWriteRights" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ENoWriteRights" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENoWriteRights *)new mvIMPACT::acquire::ENoWriteRights((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENoWriteRights, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENoWriteRights__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ENoWriteRights *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENoWriteRights" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoWriteRights" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENoWriteRights" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoWriteRights" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENoWriteRights *)new mvIMPACT::acquire::ENoWriteRights((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENoWriteRights, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENoWriteRights(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ENoWriteRights", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_ENoWriteRights__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ENoWriteRights__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ENoWriteRights'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ENoWriteRights::ENoWriteRights(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ENoWriteRights::ENoWriteRights(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ENoWriteRights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ENoWriteRights *arg1 = (mvIMPACT::acquire::ENoWriteRights *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ENoWriteRights, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ENoWriteRights" "', argument " "1"" of type '" "mvIMPACT::acquire::ENoWriteRights *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ENoWriteRights * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ENoWriteRights_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ENoWriteRights, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ENoWriteRights_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ENoModifySizeRights__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ENoModifySizeRights *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENoModifySizeRights" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoModifySizeRights" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENoModifySizeRights" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoModifySizeRights" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ENoModifySizeRights" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENoModifySizeRights *)new mvIMPACT::acquire::ENoModifySizeRights((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENoModifySizeRights, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENoModifySizeRights__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ENoModifySizeRights *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ENoModifySizeRights" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoModifySizeRights" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ENoModifySizeRights" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ENoModifySizeRights" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ENoModifySizeRights *)new mvIMPACT::acquire::ENoModifySizeRights((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ENoModifySizeRights, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ENoModifySizeRights(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ENoModifySizeRights", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_ENoModifySizeRights__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ENoModifySizeRights__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ENoModifySizeRights'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ENoModifySizeRights::ENoModifySizeRights(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ENoModifySizeRights::ENoModifySizeRights(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ENoModifySizeRights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ENoModifySizeRights *arg1 = (mvIMPACT::acquire::ENoModifySizeRights *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ENoModifySizeRights, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ENoModifySizeRights" "', argument " "1"" of type '" "mvIMPACT::acquire::ENoModifySizeRights *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ENoModifySizeRights * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ENoModifySizeRights_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ENoModifySizeRights, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ENoModifySizeRights_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EIncompatibleComponents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EIncompatibleComponents *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EIncompatibleComponents" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EIncompatibleComponents" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EIncompatibleComponents" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EIncompatibleComponents" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EIncompatibleComponents" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EIncompatibleComponents *)new mvIMPACT::acquire::EIncompatibleComponents((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EIncompatibleComponents, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EIncompatibleComponents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EIncompatibleComponents *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EIncompatibleComponents" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EIncompatibleComponents" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EIncompatibleComponents" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EIncompatibleComponents" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EIncompatibleComponents *)new mvIMPACT::acquire::EIncompatibleComponents((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EIncompatibleComponents, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EIncompatibleComponents(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_EIncompatibleComponents", 0, 3, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_new_EIncompatibleComponents__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_EIncompatibleComponents__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EIncompatibleComponents'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EIncompatibleComponents::EIncompatibleComponents(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EIncompatibleComponents::EIncompatibleComponents(std::string const &,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_EIncompatibleComponents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EIncompatibleComponents *arg1 = (mvIMPACT::acquire::EIncompatibleComponents *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EIncompatibleComponents, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EIncompatibleComponents" "', argument " "1"" of type '" "mvIMPACT::acquire::EIncompatibleComponents *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EIncompatibleComponents * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EIncompatibleComponents_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EIncompatibleComponents, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EIncompatibleComponents_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *EProperty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EProperty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EInvalidValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EInvalidValue *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidValue" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidValue" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EInvalidValue" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidValue" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EInvalidValue" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidValue *)new mvIMPACT::acquire::EInvalidValue((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidValue, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EInvalidValue *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidValue" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidValue" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EInvalidValue" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidValue" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidValue *)new mvIMPACT::acquire::EInvalidValue((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidValue, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidValue(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EInvalidValue", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_EInvalidValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_EInvalidValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EInvalidValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EInvalidValue::EInvalidValue(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EInvalidValue::EInvalidValue(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_EInvalidValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EInvalidValue *arg1 = (mvIMPACT::acquire::EInvalidValue *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EInvalidValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EInvalidValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EInvalidValue *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EInvalidValue * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EInvalidValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EInvalidValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EInvalidValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EValIDOutOfBounds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EValIDOutOfBounds *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EValIDOutOfBounds" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValIDOutOfBounds" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EValIDOutOfBounds" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValIDOutOfBounds" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EValIDOutOfBounds" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EValIDOutOfBounds *)new mvIMPACT::acquire::EValIDOutOfBounds((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EValIDOutOfBounds, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EValIDOutOfBounds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EValIDOutOfBounds *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EValIDOutOfBounds" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValIDOutOfBounds" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EValIDOutOfBounds" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValIDOutOfBounds" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EValIDOutOfBounds *)new mvIMPACT::acquire::EValIDOutOfBounds((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EValIDOutOfBounds, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EValIDOutOfBounds(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EValIDOutOfBounds", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_EValIDOutOfBounds__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_EValIDOutOfBounds__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EValIDOutOfBounds'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EValIDOutOfBounds::EValIDOutOfBounds(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EValIDOutOfBounds::EValIDOutOfBounds(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_EValIDOutOfBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EValIDOutOfBounds *arg1 = (mvIMPACT::acquire::EValIDOutOfBounds *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EValIDOutOfBounds, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EValIDOutOfBounds" "', argument " "1"" of type '" "mvIMPACT::acquire::EValIDOutOfBounds *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EValIDOutOfBounds * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EValIDOutOfBounds_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EValIDOutOfBounds, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EValIDOutOfBounds_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ETranslationTableCorrupted__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ETranslationTableCorrupted *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ETranslationTableCorrupted" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ETranslationTableCorrupted" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ETranslationTableCorrupted" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ETranslationTableCorrupted" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ETranslationTableCorrupted" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ETranslationTableCorrupted *)new mvIMPACT::acquire::ETranslationTableCorrupted((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableCorrupted, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ETranslationTableCorrupted__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ETranslationTableCorrupted *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ETranslationTableCorrupted" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ETranslationTableCorrupted" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ETranslationTableCorrupted" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ETranslationTableCorrupted" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ETranslationTableCorrupted *)new mvIMPACT::acquire::ETranslationTableCorrupted((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableCorrupted, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ETranslationTableCorrupted(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ETranslationTableCorrupted", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_ETranslationTableCorrupted__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ETranslationTableCorrupted__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ETranslationTableCorrupted'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ETranslationTableCorrupted::ETranslationTableCorrupted(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ETranslationTableCorrupted::ETranslationTableCorrupted(std::string const &,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_ETranslationTableCorrupted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::ETranslationTableCorrupted *arg1 = (mvIMPACT::acquire::ETranslationTableCorrupted *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableCorrupted, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ETranslationTableCorrupted" "', argument " "1"" of type '" "mvIMPACT::acquire::ETranslationTableCorrupted *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ETranslationTableCorrupted * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ETranslationTableCorrupted_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableCorrupted, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ETranslationTableCorrupted_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ETranslationTableNotDefined__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ETranslationTableNotDefined *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ETranslationTableNotDefined" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ETranslationTableNotDefined" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ETranslationTableNotDefined" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ETranslationTableNotDefined" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ETranslationTableNotDefined" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ETranslationTableNotDefined *)new mvIMPACT::acquire::ETranslationTableNotDefined((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableNotDefined, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ETranslationTableNotDefined__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ETranslationTableNotDefined *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ETranslationTableNotDefined" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ETranslationTableNotDefined" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ETranslationTableNotDefined" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ETranslationTableNotDefined" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ETranslationTableNotDefined *)new mvIMPACT::acquire::ETranslationTableNotDefined((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableNotDefined, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ETranslationTableNotDefined(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ETranslationTableNotDefined", 0, 3, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_new_ETranslationTableNotDefined__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ETranslationTableNotDefined__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ETranslationTableNotDefined'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ETranslationTableNotDefined::ETranslationTableNotDefined(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ETranslationTableNotDefined::ETranslationTableNotDefined(std::string const &,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_ETranslationTableNotDefined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::ETranslationTableNotDefined *arg1 = (mvIMPACT::acquire::ETranslationTableNotDefined *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableNotDefined, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ETranslationTableNotDefined" "', argument " "1"" of type '" "mvIMPACT::acquire::ETranslationTableNotDefined *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ETranslationTableNotDefined * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ETranslationTableNotDefined_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableNotDefined, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ETranslationTableNotDefined_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EInvalidValueType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EInvalidValueType *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidValueType" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidValueType" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EInvalidValueType" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidValueType" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EInvalidValueType" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidValueType *)new mvIMPACT::acquire::EInvalidValueType((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidValueType, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidValueType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EInvalidValueType *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidValueType" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidValueType" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EInvalidValueType" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidValueType" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidValueType *)new mvIMPACT::acquire::EInvalidValueType((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidValueType, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidValueType(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EInvalidValueType", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_EInvalidValueType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_EInvalidValueType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EInvalidValueType'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EInvalidValueType::EInvalidValueType(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EInvalidValueType::EInvalidValueType(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_EInvalidValueType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EInvalidValueType *arg1 = (mvIMPACT::acquire::EInvalidValueType *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EInvalidValueType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EInvalidValueType" "', argument " "1"" of type '" "mvIMPACT::acquire::EInvalidValueType *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EInvalidValueType * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EInvalidValueType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EInvalidValueType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EInvalidValueType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EValTooLarge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EValTooLarge *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EValTooLarge" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooLarge" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EValTooLarge" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooLarge" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EValTooLarge *)new mvIMPACT::acquire::EValTooLarge((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EValTooLarge, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EValTooLarge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ; int res3 = SWIG_OLDOBJ ; int res4 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EValTooLarge *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EValTooLarge" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooLarge" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EValTooLarge" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooLarge" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EValTooLarge" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooLarge" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { std::string *ptr = (std::string *)0; res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EValTooLarge" "', argument " "4"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooLarge" "', argument " "4"" of type '" "std::string const &""'"); }
     arg4 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EValTooLarge *)new mvIMPACT::acquire::EValTooLarge((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EValTooLarge, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3; if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL; }
SWIGINTERN PyObject *_wrap_new_EValTooLarge(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EValTooLarge", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_EValTooLarge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_new_EValTooLarge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EValTooLarge'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EValTooLarge::EValTooLarge(std::string const &,std::string const &)\n"
  "    mvIMPACT::acquire::EValTooLarge::EValTooLarge(std::string const &,std::string const &,std::string const &,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_EValTooLarge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EValTooLarge *arg1 = (mvIMPACT::acquire::EValTooLarge *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EValTooLarge, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EValTooLarge" "', argument " "1"" of type '" "mvIMPACT::acquire::EValTooLarge *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EValTooLarge * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EValTooLarge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EValTooLarge, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EValTooLarge_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EValTooSmall__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EValTooSmall *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EValTooSmall" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooSmall" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EValTooSmall" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooSmall" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EValTooSmall *)new mvIMPACT::acquire::EValTooSmall((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EValTooSmall, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EValTooSmall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ; int res3 = SWIG_OLDOBJ ; int res4 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EValTooSmall *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EValTooSmall" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooSmall" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EValTooSmall" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooSmall" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EValTooSmall" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooSmall" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { std::string *ptr = (std::string *)0; res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EValTooSmall" "', argument " "4"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValTooSmall" "', argument " "4"" of type '" "std::string const &""'"); }
     arg4 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EValTooSmall *)new mvIMPACT::acquire::EValTooSmall((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EValTooSmall, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3; if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL; }
SWIGINTERN PyObject *_wrap_new_EValTooSmall(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EValTooSmall", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_EValTooSmall__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_new_EValTooSmall__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EValTooSmall'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EValTooSmall::EValTooSmall(std::string const &,std::string const &)\n"
  "    mvIMPACT::acquire::EValTooSmall::EValTooSmall(std::string const &,std::string const &,std::string const &,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_EValTooSmall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EValTooSmall *arg1 = (mvIMPACT::acquire::EValTooSmall *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EValTooSmall, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EValTooSmall" "', argument " "1"" of type '" "mvIMPACT::acquire::EValTooSmall *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EValTooSmall * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EValTooSmall_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EValTooSmall, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EValTooSmall_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EValidationFailed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EValidationFailed *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EValidationFailed" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValidationFailed" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EValidationFailed" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValidationFailed" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EValidationFailed" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EValidationFailed *)new mvIMPACT::acquire::EValidationFailed((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EValidationFailed, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EValidationFailed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EValidationFailed *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EValidationFailed" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValidationFailed" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EValidationFailed" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EValidationFailed" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EValidationFailed *)new mvIMPACT::acquire::EValidationFailed((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EValidationFailed, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EValidationFailed(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EValidationFailed", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_EValidationFailed__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_EValidationFailed__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EValidationFailed'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EValidationFailed::EValidationFailed(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EValidationFailed::EValidationFailed(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_EValidationFailed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EValidationFailed *arg1 = (mvIMPACT::acquire::EValidationFailed *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EValidationFailed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EValidationFailed" "', argument " "1"" of type '" "mvIMPACT::acquire::EValidationFailed *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EValidationFailed * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EValidationFailed_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EValidationFailed, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EValidationFailed_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *EPropertyList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EPropertyList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EComponentNotFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EComponentNotFound *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "new_EComponentNotFound", 2, 2, swig_obj)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EComponentNotFound" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EComponentNotFound" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EComponentNotFound" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EComponentNotFound" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EComponentNotFound *)new mvIMPACT::acquire::EComponentNotFound((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EComponentNotFound, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_delete_EComponentNotFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EComponentNotFound *arg1 = (mvIMPACT::acquire::EComponentNotFound *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EComponentNotFound, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EComponentNotFound" "', argument " "1"" of type '" "mvIMPACT::acquire::EComponentNotFound *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EComponentNotFound * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EComponentNotFound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EComponentNotFound, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EComponentNotFound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EListEntryOccupied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject *swig_obj[1] ; mvIMPACT::acquire::EListEntryOccupied *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EListEntryOccupied" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EListEntryOccupied" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EListEntryOccupied *)new mvIMPACT::acquire::EListEntryOccupied((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EListEntryOccupied, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_delete_EListEntryOccupied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EListEntryOccupied *arg1 = (mvIMPACT::acquire::EListEntryOccupied *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EListEntryOccupied, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EListEntryOccupied" "', argument " "1"" of type '" "mvIMPACT::acquire::EListEntryOccupied *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EListEntryOccupied * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EListEntryOccupied_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EListEntryOccupied, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EListEntryOccupied_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EComponentIDInvalid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject *swig_obj[1] ; mvIMPACT::acquire::EComponentIDInvalid *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EComponentIDInvalid" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EComponentIDInvalid" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EComponentIDInvalid *)new mvIMPACT::acquire::EComponentIDInvalid((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EComponentIDInvalid, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_delete_EComponentIDInvalid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EComponentIDInvalid *arg1 = (mvIMPACT::acquire::EComponentIDInvalid *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EComponentIDInvalid, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EComponentIDInvalid" "', argument " "1"" of type '" "mvIMPACT::acquire::EComponentIDInvalid *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EComponentIDInvalid * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EComponentIDInvalid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EComponentIDInvalid, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EComponentIDInvalid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EInvalidListID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; mvIMPACT::acquire::EInvalidListID *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidListID" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidListID" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidListID *)new mvIMPACT::acquire::EInvalidListID((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidListID, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidListID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EInvalidListID *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidListID" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidListID" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EInvalidListID" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidListID" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidListID *)new mvIMPACT::acquire::EInvalidListID((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidListID, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidListID(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EInvalidListID", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_EInvalidListID__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_EInvalidListID__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EInvalidListID'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EInvalidListID::EInvalidListID(std::string const &)\n"
  "    mvIMPACT::acquire::EInvalidListID::EInvalidListID(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_EInvalidListID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EInvalidListID *arg1 = (mvIMPACT::acquire::EInvalidListID *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EInvalidListID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EInvalidListID" "', argument " "1"" of type '" "mvIMPACT::acquire::EInvalidListID *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EInvalidListID * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EInvalidListID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EInvalidListID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EInvalidListID_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ECantAccessData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ECantAccessData *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ECantAccessData" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantAccessData" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ECantAccessData" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantAccessData" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ECantAccessData" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ECantAccessData *)new mvIMPACT::acquire::ECantAccessData((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ECantAccessData, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ECantAccessData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ECantAccessData *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ECantAccessData" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantAccessData" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ECantAccessData" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantAccessData" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ECantAccessData *)new mvIMPACT::acquire::ECantAccessData((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ECantAccessData, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ECantAccessData(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ECantAccessData", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_ECantAccessData__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ECantAccessData__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ECantAccessData'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ECantAccessData::ECantAccessData(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ECantAccessData::ECantAccessData(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ECantAccessData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ECantAccessData *arg1 = (mvIMPACT::acquire::ECantAccessData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ECantAccessData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ECantAccessData" "', argument " "1"" of type '" "mvIMPACT::acquire::ECantAccessData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ECantAccessData * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ECantAccessData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ECantAccessData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ECantAccessData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ECantRegisterComponent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ECantRegisterComponent *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ECantRegisterComponent" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantRegisterComponent" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ECantRegisterComponent *)new mvIMPACT::acquire::ECantRegisterComponent((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ECantRegisterComponent, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_ECantRegisterComponent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ECantRegisterComponent *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ECantRegisterComponent" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantRegisterComponent" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ECantRegisterComponent" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantRegisterComponent" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ECantRegisterComponent *)new mvIMPACT::acquire::ECantRegisterComponent((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ECantRegisterComponent, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ECantRegisterComponent(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_ECantRegisterComponent", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_ECantRegisterComponent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ECantRegisterComponent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ECantRegisterComponent'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ECantRegisterComponent::ECantRegisterComponent(std::string const &)\n"
  "    mvIMPACT::acquire::ECantRegisterComponent::ECantRegisterComponent(std::string const &,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_ECantRegisterComponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ECantRegisterComponent *arg1 = (mvIMPACT::acquire::ECantRegisterComponent *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ECantRegisterComponent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ECantRegisterComponent" "', argument " "1"" of type '" "mvIMPACT::acquire::ECantRegisterComponent *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ECantRegisterComponent * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ECantRegisterComponent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ECantRegisterComponent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ECantRegisterComponent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *EMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EMethodPtrInvalid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EMethodPtrInvalid *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EMethodPtrInvalid" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EMethodPtrInvalid" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EMethodPtrInvalid" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EMethodPtrInvalid" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EMethodPtrInvalid" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EMethodPtrInvalid *)new mvIMPACT::acquire::EMethodPtrInvalid((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EMethodPtrInvalid, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EMethodPtrInvalid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EMethodPtrInvalid *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EMethodPtrInvalid" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EMethodPtrInvalid" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EMethodPtrInvalid" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EMethodPtrInvalid" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EMethodPtrInvalid *)new mvIMPACT::acquire::EMethodPtrInvalid((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EMethodPtrInvalid, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EMethodPtrInvalid(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EMethodPtrInvalid", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_EMethodPtrInvalid__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_EMethodPtrInvalid__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EMethodPtrInvalid'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EMethodPtrInvalid::EMethodPtrInvalid(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EMethodPtrInvalid::EMethodPtrInvalid(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_EMethodPtrInvalid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EMethodPtrInvalid *arg1 = (mvIMPACT::acquire::EMethodPtrInvalid *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EMethodPtrInvalid, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EMethodPtrInvalid" "', argument " "1"" of type '" "mvIMPACT::acquire::EMethodPtrInvalid *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EMethodPtrInvalid * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EMethodPtrInvalid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EMethodPtrInvalid, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EMethodPtrInvalid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EInvalidParameterList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EInvalidParameterList *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidParameterList" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidParameterList" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidParameterList *)new mvIMPACT::acquire::EInvalidParameterList((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidParameterList, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidParameterList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EInvalidParameterList *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidParameterList" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidParameterList" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EInvalidParameterList" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidParameterList" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidParameterList *)new mvIMPACT::acquire::EInvalidParameterList((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidParameterList, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidParameterList(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_EInvalidParameterList", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_EInvalidParameterList__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_EInvalidParameterList__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EInvalidParameterList'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EInvalidParameterList::EInvalidParameterList(std::string const &)\n"
  "    mvIMPACT::acquire::EInvalidParameterList::EInvalidParameterList(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_EInvalidParameterList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EInvalidParameterList *arg1 = (mvIMPACT::acquire::EInvalidParameterList *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EInvalidParameterList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EInvalidParameterList" "', argument " "1"" of type '" "mvIMPACT::acquire::EInvalidParameterList *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EInvalidParameterList * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EInvalidParameterList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EInvalidParameterList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EInvalidParameterList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EUnsupportedParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::EUnsupportedParameter *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EUnsupportedParameter" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EUnsupportedParameter" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EUnsupportedParameter *)new mvIMPACT::acquire::EUnsupportedParameter((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedParameter, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_delete_EUnsupportedParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EUnsupportedParameter *arg1 = (mvIMPACT::acquire::EUnsupportedParameter *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedParameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EUnsupportedParameter" "', argument " "1"" of type '" "mvIMPACT::acquire::EUnsupportedParameter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EUnsupportedParameter * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EUnsupportedParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedParameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EUnsupportedParameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ESizeMismatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::ESizeMismatch *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "new_ESizeMismatch", 2, 2, swig_obj)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ESizeMismatch" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ESizeMismatch" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ESizeMismatch" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ESizeMismatch" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ESizeMismatch *)new mvIMPACT::acquire::ESizeMismatch((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ESizeMismatch, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_delete_ESizeMismatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ESizeMismatch *arg1 = (mvIMPACT::acquire::ESizeMismatch *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ESizeMismatch, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ESizeMismatch" "', argument " "1"" of type '" "mvIMPACT::acquire::ESizeMismatch *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ESizeMismatch * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ESizeMismatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ESizeMismatch, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ESizeMismatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EImplementationMissing__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EImplementationMissing *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EImplementationMissing" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EImplementationMissing" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EImplementationMissing *)new mvIMPACT::acquire::EImplementationMissing((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EImplementationMissing, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_EImplementationMissing__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EImplementationMissing *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EImplementationMissing" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EImplementationMissing" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EImplementationMissing" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EImplementationMissing" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EImplementationMissing *)new mvIMPACT::acquire::EImplementationMissing((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EImplementationMissing, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EImplementationMissing(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_EImplementationMissing", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_EImplementationMissing__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_EImplementationMissing__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EImplementationMissing'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EImplementationMissing::EImplementationMissing(std::string const &)\n"
  "    mvIMPACT::acquire::EImplementationMissing::EImplementationMissing(std::string const &,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_EImplementationMissing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EImplementationMissing *arg1 = (mvIMPACT::acquire::EImplementationMissing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EImplementationMissing, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EImplementationMissing" "', argument " "1"" of type '" "mvIMPACT::acquire::EImplementationMissing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EImplementationMissing * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EImplementationMissing_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EImplementationMissing, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EImplementationMissing_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EInvalidInputParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EInvalidInputParameter *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidInputParameter" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidInputParameter" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidInputParameter *)new mvIMPACT::acquire::EInvalidInputParameter((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidInputParameter, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidInputParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EInvalidInputParameter *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidInputParameter" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidInputParameter" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EInvalidInputParameter" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidInputParameter" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidInputParameter *)new mvIMPACT::acquire::EInvalidInputParameter((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidInputParameter, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidInputParameter(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_EInvalidInputParameter", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_EInvalidInputParameter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_EInvalidInputParameter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EInvalidInputParameter'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EInvalidInputParameter::EInvalidInputParameter(std::string const &)\n"
  "    mvIMPACT::acquire::EInvalidInputParameter::EInvalidInputParameter(std::string const &,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_EInvalidInputParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EInvalidInputParameter *arg1 = (mvIMPACT::acquire::EInvalidInputParameter *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EInvalidInputParameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EInvalidInputParameter" "', argument " "1"" of type '" "mvIMPACT::acquire::EInvalidInputParameter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EInvalidInputParameter * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EInvalidInputParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EInvalidInputParameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EInvalidInputParameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EInputBufferTooSmall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject *swig_obj[1] ; mvIMPACT::acquire::EInputBufferTooSmall *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInputBufferTooSmall" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInputBufferTooSmall" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInputBufferTooSmall *)new mvIMPACT::acquire::EInputBufferTooSmall((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInputBufferTooSmall, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_delete_EInputBufferTooSmall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EInputBufferTooSmall *arg1 = (mvIMPACT::acquire::EInputBufferTooSmall *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EInputBufferTooSmall, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EInputBufferTooSmall" "', argument " "1"" of type '" "mvIMPACT::acquire::EInputBufferTooSmall *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EInputBufferTooSmall * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EInputBufferTooSmall_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EInputBufferTooSmall, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EInputBufferTooSmall_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EWrongParamCount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; mvIMPACT::acquire::EWrongParamCount *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EWrongParamCount" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EWrongParamCount" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EWrongParamCount *)new mvIMPACT::acquire::EWrongParamCount((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EWrongParamCount, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_EWrongParamCount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EWrongParamCount *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EWrongParamCount" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EWrongParamCount" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EWrongParamCount" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EWrongParamCount" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EWrongParamCount *)new mvIMPACT::acquire::EWrongParamCount((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EWrongParamCount, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EWrongParamCount(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EWrongParamCount", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_EWrongParamCount__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_EWrongParamCount__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EWrongParamCount'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EWrongParamCount::EWrongParamCount(std::string const &)\n"
  "    mvIMPACT::acquire::EWrongParamCount::EWrongParamCount(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_EWrongParamCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EWrongParamCount *arg1 = (mvIMPACT::acquire::EWrongParamCount *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EWrongParamCount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EWrongParamCount" "', argument " "1"" of type '" "mvIMPACT::acquire::EWrongParamCount *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EWrongParamCount * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EWrongParamCount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EWrongParamCount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EWrongParamCount_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EUnsupportedOperation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::EUnsupportedOperation *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EUnsupportedOperation" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EUnsupportedOperation" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EUnsupportedOperation *)new mvIMPACT::acquire::EUnsupportedOperation((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedOperation, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_delete_EUnsupportedOperation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EUnsupportedOperation *arg1 = (mvIMPACT::acquire::EUnsupportedOperation *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedOperation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EUnsupportedOperation" "', argument " "1"" of type '" "mvIMPACT::acquire::EUnsupportedOperation *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EUnsupportedOperation * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EUnsupportedOperation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedOperation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EUnsupportedOperation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ECantSerializeData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ECantSerializeData *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ECantSerializeData" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantSerializeData" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ECantSerializeData" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantSerializeData" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ECantSerializeData" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ECantSerializeData *)new mvIMPACT::acquire::ECantSerializeData((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ECantSerializeData, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ECantSerializeData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::ECantSerializeData *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ECantSerializeData" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantSerializeData" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ECantSerializeData" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantSerializeData" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ECantSerializeData *)new mvIMPACT::acquire::ECantSerializeData((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ECantSerializeData, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ECantSerializeData(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ECantSerializeData", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_ECantSerializeData__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ECantSerializeData__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ECantSerializeData'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ECantSerializeData::ECantSerializeData(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::ECantSerializeData::ECantSerializeData(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ECantSerializeData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ECantSerializeData *arg1 = (mvIMPACT::acquire::ECantSerializeData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ECantSerializeData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ECantSerializeData" "', argument " "1"" of type '" "mvIMPACT::acquire::ECantSerializeData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ECantSerializeData * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ECantSerializeData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ECantSerializeData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ECantSerializeData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EInvalidFileContent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; bool arg3 ; int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EInvalidFileContent *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidFileContent" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidFileContent" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EInvalidFileContent" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidFileContent" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EInvalidFileContent" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidFileContent *)new mvIMPACT::acquire::EInvalidFileContent((std::string const &)*arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidFileContent, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidFileContent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::EInvalidFileContent *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EInvalidFileContent" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidFileContent" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EInvalidFileContent" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EInvalidFileContent" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EInvalidFileContent *)new mvIMPACT::acquire::EInvalidFileContent((std::string const &)*arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EInvalidFileContent, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res1)) delete arg1; if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EInvalidFileContent(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EInvalidFileContent", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_EInvalidFileContent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_EInvalidFileContent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EInvalidFileContent'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EInvalidFileContent::EInvalidFileContent(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EInvalidFileContent::EInvalidFileContent(std::string const &,std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_EInvalidFileContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EInvalidFileContent *arg1 = (mvIMPACT::acquire::EInvalidFileContent *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EInvalidFileContent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EInvalidFileContent" "', argument " "1"" of type '" "mvIMPACT::acquire::EInvalidFileContent *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EInvalidFileContent * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EInvalidFileContent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EInvalidFileContent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EInvalidFileContent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ECantAllocateNewList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject *swig_obj[1] ; mvIMPACT::acquire::ECantAllocateNewList *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ECantAllocateNewList" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ECantAllocateNewList" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ECantAllocateNewList *)new mvIMPACT::acquire::ECantAllocateNewList((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ECantAllocateNewList, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_delete_ECantAllocateNewList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ECantAllocateNewList *arg1 = (mvIMPACT::acquire::ECantAllocateNewList *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ECantAllocateNewList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ECantAllocateNewList" "', argument " "1"" of type '" "mvIMPACT::acquire::ECantAllocateNewList *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ECantAllocateNewList * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ECantAllocateNewList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ECantAllocateNewList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ECantAllocateNewList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ExceptionFactory_getLastErrorString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; std::string result;
  if (!SWIG_Python_UnpackTuple(args, "ExceptionFactory_getLastErrorString", 0, 0, 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = mvIMPACT::acquire::ExceptionFactory::getLastErrorString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ExceptionFactory_raiseException__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int arg2 ; int arg3 ; mvIMPACT::acquire::HOBJ arg4 ; int res1 ;
  char *buf1 = 0 ; int alloc1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExceptionFactory_raiseException" "', argument " "1"" of type '" "char const *""'"); }
   arg1 = reinterpret_cast< char * >(buf1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExceptionFactory_raiseException" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExceptionFactory_raiseException" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ExceptionFactory_raiseException" "', argument " "4"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg4 = static_cast< mvIMPACT::acquire::HOBJ >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT::acquire::ExceptionFactory::raiseException((char const *)arg1,arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return resultobj; fail: if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; }
SWIGINTERN PyObject *_wrap_ExceptionFactory_raiseException__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int arg2 ; int arg3 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ;
  int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExceptionFactory_raiseException" "', argument " "1"" of type '" "char const *""'"); }
   arg1 = reinterpret_cast< char * >(buf1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExceptionFactory_raiseException" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExceptionFactory_raiseException" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT::acquire::ExceptionFactory::raiseException((char const *)arg1,arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return resultobj; fail: if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; }
SWIGINTERN PyObject *_wrap_ExceptionFactory_raiseException__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int arg2 ; mvIMPACT::acquire::TDMR_ERROR arg3 ; std::string *arg4 = 0 ;
  int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; int res4 = SWIG_OLDOBJ ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExceptionFactory_raiseException" "', argument " "1"" of type '" "char const *""'"); }
   arg1 = reinterpret_cast< char * >(buf1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExceptionFactory_raiseException" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExceptionFactory_raiseException" "', argument " "3"" of type '" "mvIMPACT::acquire::TDMR_ERROR""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDMR_ERROR >(val3); { std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExceptionFactory_raiseException" "', argument " "4"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExceptionFactory_raiseException" "', argument " "4"" of type '" "std::string const &""'"); }
     arg4 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT::acquire::ExceptionFactory::raiseException((char const *)arg1,arg2,arg3,(std::string const &)*arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1; if (SWIG_IsNewObj(res4)) delete arg4; return resultobj; fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1; if (SWIG_IsNewObj(res4)) delete arg4; return NULL; }
SWIGINTERN PyObject *_wrap_ExceptionFactory_raiseException(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "ExceptionFactory_raiseException", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 3) { PyObject *retobj = _wrap_ExceptionFactory_raiseException__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[3], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_2;
    return _wrap_ExceptionFactory_raiseException__SWIG_0(self, argc, argv);}  check_2: if (argc == 4) {
    PyObject *retobj = _wrap_ExceptionFactory_raiseException__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ExceptionFactory_raiseException'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ExceptionFactory::raiseException(char const *,int,int,mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::ExceptionFactory::raiseException(char const *,int,int)\n"
  "    mvIMPACT::acquire::ExceptionFactory::raiseException(char const *,int,mvIMPACT::acquire::TDMR_ERROR,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_new_ExceptionFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ExceptionFactory *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "new_ExceptionFactory", 0, 0, 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ExceptionFactory *)new mvIMPACT::acquire::ExceptionFactory();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ExceptionFactory, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ExceptionFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ExceptionFactory *arg1 = (mvIMPACT::acquire::ExceptionFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ExceptionFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExceptionFactory" "', argument " "1"" of type '" "mvIMPACT::acquire::ExceptionFactory *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ExceptionFactory * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ExceptionFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ExceptionFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExceptionFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_ComponentAccess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentAccess *arg1 = (mvIMPACT::acquire::ComponentAccess *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComponentAccess" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentAccess *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentAccess * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentAccess__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentAccess *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ComponentAccess *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComponentAccess" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentAccess const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComponentAccess" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentAccess const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentAccess * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentAccess *)new mvIMPACT::acquire::ComponentAccess((mvIMPACT::acquire::ComponentAccess const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentAccess(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ComponentAccess", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_ComponentAccess__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ComponentAccess'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ComponentAccess::ComponentAccess(mvIMPACT::acquire::ComponentAccess const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_ComponentAccess_changedCounter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentAccess *arg1 = (mvIMPACT::acquire::ComponentAccess *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentAccess_changedCounter" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentAccess const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentAccess * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::ComponentAccess const *)arg1)->changedCounter();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentAccess_changedCounterAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentAccess *arg1 = (mvIMPACT::acquire::ComponentAccess *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentAccess_changedCounterAttr" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentAccess const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentAccess * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::ComponentAccess const *)arg1)->changedCounterAttr();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentAccess_hObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentAccess *arg1 = (mvIMPACT::acquire::ComponentAccess *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::HOBJ result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentAccess_hObj" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentAccess const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentAccess * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentAccess const *)arg1)->hObj();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentAccess_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentAccess *arg1 = (mvIMPACT::acquire::ComponentAccess *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentAccess_name" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentAccess const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentAccess * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::ComponentAccess const *)arg1)->name(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentAccess_displayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentAccess *arg1 = (mvIMPACT::acquire::ComponentAccess *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentAccess_displayName" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentAccess const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentAccess * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::ComponentAccess const *)arg1)->displayName(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ComponentAccess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ComponentAccess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Component__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ; mvIMPACT::acquire::Component *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Component" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Component *)new mvIMPACT::acquire::Component(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Component__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::Component *)new mvIMPACT::acquire::Component();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Component__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::Component *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__Component,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Component" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Component" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Component *)new mvIMPACT::acquire::Component((mvIMPACT::acquire::Component const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Component(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Component", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_Component__SWIG_1(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_Component__SWIG_2(self, argc, argv);}  check_2:
  if (argc == 1) { PyObject *retobj = _wrap_new_Component__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Component'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Component::Component(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::Component::Component()\n"
  "    mvIMPACT::acquire::Component::Component(mvIMPACT::acquire::Component const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_Component_firstSibling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::Component result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_firstSibling" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->firstSibling(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_lastSibling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::Component result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_lastSibling" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->lastSibling(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_nextSibling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::Component result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_nextSibling" "', argument " "1"" of type '" "mvIMPACT::acquire::Component *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->nextSibling(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_firstChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::Component result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_firstChild" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->firstChild(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_parent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::Component result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_parent" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->parent(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_docString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_docString" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->docString(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_flags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::TComponentFlag result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_flags" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TComponentFlag)((mvIMPACT::acquire::Component const *)arg1)->flags();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_flagsAsString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; std::string result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_flagsAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Component_flagsAsString" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Component_flagsAsString" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->flagsAsString((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj;
  fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_Component_flagsAsString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_flagsAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->flagsAsString(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_flagsAsString(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "Component_flagsAsString", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_Component_flagsAsString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_Component_flagsAsString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Component_flagsAsString'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Component::flagsAsString(std::string const &) const\n"
  "    mvIMPACT::acquire::Component::flagsAsString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_Component_getIsDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_getIsDefault" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isDefault(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getIsList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_getIsList" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isList(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getIsMeth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_getIsMeth" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isMeth(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getIsProp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_getIsProp" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isProp(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_getIsValid" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isValid(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getIsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_getIsVisible" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isVisible(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getIsWriteable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_getIsWriteable" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isWriteable(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_restoreDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::Component *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_restoreDefault" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Component *) &((mvIMPACT::acquire::Component const *)arg1)->restoreDefault();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::TComponentType result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_type" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TComponentType)((mvIMPACT::acquire::Component const *)arg1)->type();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TComponentType result;
  if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Component_getType" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TComponentType)mvIMPACT::acquire::Component::type(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_typeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_typeAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->typeAsString(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_visibility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::TComponentVisibility result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_visibility" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TComponentVisibility)((mvIMPACT::acquire::Component const *)arg1)->visibility();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_visibilityAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_visibilityAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->visibilityAsString(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getVisibilityAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TComponentVisibility arg1 ; int val1 ; int ecode1 = 0 ; PyObject *swig_obj[1] ;
  std::string result; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Component_getVisibilityAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::TComponentVisibility""'"); }
    arg1 = static_cast< mvIMPACT::acquire::TComponentVisibility >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = mvIMPACT::acquire::Component::visibilityAsString(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_representation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::TComponentRepresentation result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_representation" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TComponentRepresentation)((mvIMPACT::acquire::Component const *)arg1)->representation();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_representationAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_representationAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->representationAsString(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getRepresentationAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TComponentRepresentation arg1 ; int val1 ; int ecode1 = 0 ;
  PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Component_getRepresentationAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::TComponentRepresentation""'"); }
    arg1 = static_cast< mvIMPACT::acquire::TComponentRepresentation >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = mvIMPACT::acquire::Component::representationAsString(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_selectedFeatureCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_selectedFeatureCount" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Component const *)arg1)->selectedFeatureCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_selectingFeatureCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_selectingFeatureCount" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Component const *)arg1)->selectingFeatureCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_selectedFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ;
  std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; unsigned int result;
  if (!SWIG_Python_UnpackTuple(args, "Component_selectedFeatures", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_selectedFeatures" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_mvIMPACT__acquire__Component_std__allocatorT_mvIMPACT__acquire__Component_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Component_selectedFeatures" "', argument " "2"" of type '" "std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Component_selectedFeatures" "', argument " "2"" of type '" "std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > > &""'"); }
  
  arg2 = reinterpret_cast< std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > > * >(argp2);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Component const *)arg1)->selectedFeatures(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_selectingFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ;
  std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; unsigned int result;
  if (!SWIG_Python_UnpackTuple(args, "Component_selectingFeatures", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_selectingFeatures" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_mvIMPACT__acquire__Component_std__allocatorT_mvIMPACT__acquire__Component_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Component_selectingFeatures" "', argument " "2"" of type '" "std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Component_selectingFeatures" "', argument " "2"" of type '" "std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > > &""'"); }
  
  arg2 = reinterpret_cast< std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > > * >(argp2);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Component const *)arg1)->selectingFeatures(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_selectedFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::Component result;
  if (!SWIG_Python_UnpackTuple(args, "Component_selectedFeature", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_selectedFeature" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Component_selectedFeature" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->selectedFeature(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_selectingFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::Component result;
  if (!SWIG_Python_UnpackTuple(args, "Component_selectingFeature", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Component_selectingFeature" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Component_selectingFeature" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Component const *)arg1)->selectingFeature(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_Component(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Component" "', argument " "1"" of type '" "mvIMPACT::acquire::Component *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *Component_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Component_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ComponentCallback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; void *arg2 = (void *) 0 ; int res2 ;
  mvIMPACT::acquire::ComponentCallback *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComponentCallback" "', argument " "2"" of type '" "void *""'");  }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if ( arg1 != Py_None ) { 
          result = (mvIMPACT::acquire::ComponentCallback *)new SwigDirector_ComponentCallback(arg1,arg2);  }  else {
          result = (mvIMPACT::acquire::ComponentCallback *)new mvIMPACT::acquire::ComponentCallback(arg2);  } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentCallback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; mvIMPACT::acquire::ComponentCallback *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; arg1 = swig_obj[0]; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {  result = (mvIMPACT::acquire::ComponentCallback *)new SwigDirector_ComponentCallback(arg1);  }
         else { result = (mvIMPACT::acquire::ComponentCallback *)new mvIMPACT::acquire::ComponentCallback();  } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentCallback__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; mvIMPACT::acquire::ComponentCallback *arg2 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; mvIMPACT::acquire::ComponentCallback *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0]; res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComponentCallback" "', argument " "2"" of type '" "mvIMPACT::acquire::ComponentCallback const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComponentCallback" "', argument " "2"" of type '" "mvIMPACT::acquire::ComponentCallback const &""'"); }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ComponentCallback * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) { 
          result = (mvIMPACT::acquire::ComponentCallback *)new SwigDirector_ComponentCallback(arg1,(mvIMPACT::acquire::ComponentCallback const &)*arg2);  }
         else {
          result = (mvIMPACT::acquire::ComponentCallback *)new mvIMPACT::acquire::ComponentCallback((mvIMPACT::acquire::ComponentCallback const &)*arg2);  }
         SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentCallback(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ComponentCallback", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_ComponentCallback__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_ComponentCallback__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 2) { PyObject *retobj = _wrap_new_ComponentCallback__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ComponentCallback'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ComponentCallback::ComponentCallback(void *)\n"
  "    mvIMPACT::acquire::ComponentCallback::ComponentCallback()\n"
  "    mvIMPACT::acquire::ComponentCallback::ComponentCallback(PyObject *,mvIMPACT::acquire::ComponentCallback const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_ComponentCallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentCallback *arg1 = (mvIMPACT::acquire::ComponentCallback *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComponentCallback" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCallback *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCallback * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentCallback_isComponentRegistered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentCallback *arg1 = (mvIMPACT::acquire::ComponentCallback *) 0 ;
  mvIMPACT::acquire::Component arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject *swig_obj[2] ;
  bool result; if (!SWIG_Python_UnpackTuple(args, "ComponentCallback_isComponentRegistered", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentCallback_isComponentRegistered" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCallback const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCallback * >(argp1); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__Component,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentCallback_isComponentRegistered" "', argument " "2"" of type '" "mvIMPACT::acquire::Component""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentCallback_isComponentRegistered" "', argument " "2"" of type '" "mvIMPACT::acquire::Component""'"); }
     else { mvIMPACT::acquire::Component * temp = reinterpret_cast< mvIMPACT::acquire::Component * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::ComponentCallback const *)arg1)->isComponentRegistered(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentCallback_registerComponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentCallback *arg1 = (mvIMPACT::acquire::ComponentCallback *) 0 ;
  mvIMPACT::acquire::Component arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject *swig_obj[2] ;
  bool result; if (!SWIG_Python_UnpackTuple(args, "ComponentCallback_registerComponent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentCallback_registerComponent" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCallback *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCallback * >(argp1); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__Component,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentCallback_registerComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentCallback_registerComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component""'"); }
     else { mvIMPACT::acquire::Component * temp = reinterpret_cast< mvIMPACT::acquire::Component * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)(arg1)->registerComponent(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentCallback_unregisterComponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentCallback *arg1 = (mvIMPACT::acquire::ComponentCallback *) 0 ;
  mvIMPACT::acquire::Component arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject *swig_obj[2] ;
  bool result; if (!SWIG_Python_UnpackTuple(args, "ComponentCallback_unregisterComponent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentCallback_unregisterComponent" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCallback *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCallback * >(argp1); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__Component,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentCallback_unregisterComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentCallback_unregisterComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component""'"); }
     else { mvIMPACT::acquire::Component * temp = reinterpret_cast< mvIMPACT::acquire::Component * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)(arg1)->unregisterComponent(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentCallback_execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentCallback *arg1 = (mvIMPACT::acquire::ComponentCallback *) 0 ;
  mvIMPACT::acquire::Component *arg2 = 0 ; void *arg3 = (void *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; int res3 ; PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false;
  if (!SWIG_Python_UnpackTuple(args, "ComponentCallback_execute", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentCallback_execute" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCallback *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__Component,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentCallback_execute" "', argument " "2"" of type '" "mvIMPACT::acquire::Component &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentCallback_execute" "', argument " "2"" of type '" "mvIMPACT::acquire::Component &""'"); }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0); if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComponentCallback_execute" "', argument " "3"" of type '" "void *""'");  }
   director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try {
        if (upcall) { (arg1)->mvIMPACT::acquire::ComponentCallback::execute(*arg2,arg3); }  else { (arg1)->execute(*arg2,arg3); }
         }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_disown_ComponentCallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentCallback *arg1 = (mvIMPACT::acquire::ComponentCallback *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ComponentCallback" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCallback *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCallback * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); if (director) director->swig_disown(); } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ComponentCallback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ComponentCallback_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ComponentLocatorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentLocatorBase *)new mvIMPACT::acquire::ComponentLocatorBase();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentLocatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HLIST arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::ComponentLocatorBase *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ComponentLocatorBase" "', argument " "1"" of type '" "mvIMPACT::acquire::HLIST""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HLIST >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentLocatorBase *)new mvIMPACT::acquire::ComponentLocatorBase(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentLocatorBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HLIST arg1 ; std::string *arg2 = 0 ; int val1 ; int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::ComponentLocatorBase *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ComponentLocatorBase" "', argument " "1"" of type '" "mvIMPACT::acquire::HLIST""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HLIST >(val1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComponentLocatorBase" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComponentLocatorBase" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentLocatorBase *)new mvIMPACT::acquire::ComponentLocatorBase(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentLocatorBase__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ComponentLocatorBase *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComponentLocatorBase" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComponentLocatorBase" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentLocatorBase *)new mvIMPACT::acquire::ComponentLocatorBase((mvIMPACT::acquire::ComponentLocatorBase const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentLocatorBase(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_ComponentLocatorBase", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_ComponentLocatorBase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_ComponentLocatorBase__SWIG_3(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_ComponentLocatorBase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ComponentLocatorBase__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ComponentLocatorBase'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ComponentLocatorBase::ComponentLocatorBase()\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::ComponentLocatorBase(mvIMPACT::acquire::HLIST)\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::ComponentLocatorBase(mvIMPACT::acquire::HLIST,std::string const &)\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::ComponentLocatorBase(mvIMPACT::acquire::ComponentLocatorBase const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindComponent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  mvIMPACT::acquire::Component *arg2 = 0 ; std::string *arg3 = 0 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; int res3 = SWIG_OLDOBJ ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; bool result;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__Component,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_bindComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component &""'"); }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp2); { std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_bindComponent" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->bindComponent(*arg2,(std::string const &)*arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail:
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindComponent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  mvIMPACT::acquire::Component *arg2 = 0 ; std::string *arg3 = 0 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; int res3 = SWIG_OLDOBJ ; int val4 ; int ecode4 = 0 ; bool result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__Component,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_bindComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component &""'"); }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp2); { std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_bindComponent" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->bindComponent(*arg2,(std::string const &)*arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail:
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindComponent__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  mvIMPACT::acquire::Component *arg2 = 0 ; std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; int res3 = SWIG_OLDOBJ ; bool result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__Component,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_bindComponent" "', argument " "2"" of type '" "mvIMPACT::acquire::Component &""'"); }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp2); { std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComponentLocatorBase_bindComponent" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_bindComponent" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->bindComponent(*arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail:
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindComponent(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "ComponentLocatorBase_bindComponent", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 3) { PyObject *retobj = _wrap_ComponentLocatorBase_bindComponent__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_ComponentLocatorBase_bindComponent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_ComponentLocatorBase_bindComponent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComponentLocatorBase_bindComponent'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::bindComponent(mvIMPACT::acquire::Component &,std::string const &,int,int) const\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::bindComponent(mvIMPACT::acquire::Component &,std::string const &,int) const\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::bindComponent(mvIMPACT::acquire::Component &,std::string const &) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindSearchBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  mvIMPACT::acquire::HLIST arg2 ; std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ; mvIMPACT::acquire::HLIST result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentLocatorBase_bindSearchBase" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComponentLocatorBase_bindSearchBase" "', argument " "2"" of type '" "mvIMPACT::acquire::HLIST""'"); }
    arg2 = static_cast< mvIMPACT::acquire::HLIST >(val2); { std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComponentLocatorBase_bindSearchBase" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_bindSearchBase" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HLIST)(arg1)->bindSearchBase(arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail:
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindSearchBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  mvIMPACT::acquire::HLIST arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::HLIST result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentLocatorBase_bindSearchBase" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComponentLocatorBase_bindSearchBase" "', argument " "2"" of type '" "mvIMPACT::acquire::HLIST""'"); }
    arg2 = static_cast< mvIMPACT::acquire::HLIST >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HLIST)(arg1)->bindSearchBase(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindSearchBase(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "ComponentLocatorBase_bindSearchBase", 0, 3, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_ComponentLocatorBase_bindSearchBase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_ComponentLocatorBase_bindSearchBase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComponentLocatorBase_bindSearchBase'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::bindSearchBase(mvIMPACT::acquire::HLIST,std::string const &)\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::bindSearchBase(mvIMPACT::acquire::HLIST)\n"); return 0; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_findComponent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  std::string *arg2 = 0 ; int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; mvIMPACT::acquire::HOBJ result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentLocatorBase_findComponent" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentLocatorBase_findComponent" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_findComponent" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComponentLocatorBase_findComponent" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ComponentLocatorBase_findComponent" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->findComponent((std::string const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_findComponent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  std::string *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::HOBJ result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentLocatorBase_findComponent" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentLocatorBase_findComponent" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_findComponent" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComponentLocatorBase_findComponent" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->findComponent((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_findComponent__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::HOBJ result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentLocatorBase_findComponent" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComponentLocatorBase_findComponent" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComponentLocatorBase_findComponent" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->findComponent((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_findComponent(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "ComponentLocatorBase_findComponent", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_ComponentLocatorBase_findComponent__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_ComponentLocatorBase_findComponent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_ComponentLocatorBase_findComponent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComponentLocatorBase_findComponent'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::findComponent(std::string const &,int,int) const\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::findComponent(std::string const &,int) const\n"
  "    mvIMPACT::acquire::ComponentLocatorBase::findComponent(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_searchbase_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::HLIST result; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentLocatorBase_searchbase_id" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HLIST)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->searchbase_id();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ComponentLocatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *arg1 = (mvIMPACT::acquire::ComponentLocatorBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComponentLocatorBase" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocatorBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocatorBase * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ComponentLocatorBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ComponentLocatorBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ComponentLocator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentLocator *)new mvIMPACT::acquire::ComponentLocator();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentLocator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HLIST arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::ComponentLocator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::HLIST""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HLIST >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentLocator *)new mvIMPACT::acquire::ComponentLocator(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentLocator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HLIST arg1 ; std::string *arg2 = 0 ; int val1 ; int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::ComponentLocator *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::HLIST""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HLIST >(val1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComponentLocator" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComponentLocator" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentLocator *)new mvIMPACT::acquire::ComponentLocator(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentLocator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocator *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ComponentLocator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocator const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocator const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocator * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentLocator *)new mvIMPACT::acquire::ComponentLocator((mvIMPACT::acquire::ComponentLocator const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentLocator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ComponentLocator", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_ComponentLocator__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_ComponentLocator__SWIG_3(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_ComponentLocator__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ComponentLocator__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ComponentLocator'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ComponentLocator::ComponentLocator()\n"
  "    mvIMPACT::acquire::ComponentLocator::ComponentLocator(mvIMPACT::acquire::HLIST)\n"
  "    mvIMPACT::acquire::ComponentLocator::ComponentLocator(mvIMPACT::acquire::HLIST,std::string const &)\n"
  "    mvIMPACT::acquire::ComponentLocator::ComponentLocator(mvIMPACT::acquire::ComponentLocator const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ComponentLocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentLocator *arg1 = (mvIMPACT::acquire::ComponentLocator *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentLocator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentLocator * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ComponentLocator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ComponentLocator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ComponentList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HLIST arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::ComponentList *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ComponentList" "', argument " "1"" of type '" "mvIMPACT::acquire::HLIST""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HLIST >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentList *)new mvIMPACT::acquire::ComponentList(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentList, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentList *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::ComponentList *)new mvIMPACT::acquire::ComponentList();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentList, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentList__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentList *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ComponentList *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__ComponentList,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComponentList" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentList const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComponentList" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentList const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentList * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentList *)new mvIMPACT::acquire::ComponentList((mvIMPACT::acquire::ComponentList const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentList, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ComponentList(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ComponentList", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_ComponentList__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__ComponentList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_ComponentList__SWIG_2(self, argc, argv);}  check_2:
  if (argc == 1) { PyObject *retobj = _wrap_new_ComponentList__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ComponentList'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ComponentList::ComponentList(mvIMPACT::acquire::HLIST)\n"
  "    mvIMPACT::acquire::ComponentList::ComponentList()\n"
  "    mvIMPACT::acquire::ComponentList::ComponentList(mvIMPACT::acquire::ComponentList const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_ComponentList_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentList *arg1 = (mvIMPACT::acquire::ComponentList *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentList, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentList_size" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentList const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentList * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::ComponentList const *)arg1)->size(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentList_contentDescriptor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentList *arg1 = (mvIMPACT::acquire::ComponentList *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentList, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentList_contentDescriptor" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentList const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentList * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::ComponentList const *)arg1)->contentDescriptor(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ComponentList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentList *arg1 = (mvIMPACT::acquire::ComponentList *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComponentList" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentList *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentList * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ComponentList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ComponentList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ComponentList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Method__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ; mvIMPACT::acquire::Method *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Method" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Method *)new mvIMPACT::acquire::Method(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Method__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Method *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::Method *)new mvIMPACT::acquire::Method();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Method__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Method *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::Method *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__Method,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Method" "', argument " "1"" of type '" "mvIMPACT::acquire::Method const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Method" "', argument " "1"" of type '" "mvIMPACT::acquire::Method const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Method * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Method *)new mvIMPACT::acquire::Method((mvIMPACT::acquire::Method const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Method(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Method", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_Method__SWIG_1(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__Method, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_Method__SWIG_2(self, argc, argv);}  check_2:
  if (argc == 1) { PyObject *retobj = _wrap_new_Method__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Method'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Method::Method(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::Method::Method()\n" "    mvIMPACT::acquire::Method::Method(mvIMPACT::acquire::Method const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_Method_call__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Method *arg1 = (mvIMPACT::acquire::Method *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Method_call" "', argument " "1"" of type '" "mvIMPACT::acquire::Method const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Method * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Method_call" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Method_call" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Method const *)arg1)->call((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Method_call__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Method *arg1 = (mvIMPACT::acquire::Method *) 0 ; std::string *arg2 = 0 ;
  std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int res3 = SWIG_OLDOBJ ; int result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Method_call" "', argument " "1"" of type '" "mvIMPACT::acquire::Method const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Method * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Method_call" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Method_call" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Method_call" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Method_call" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Method const *)arg1)->call((std::string const &)*arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_Method_call__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Method *arg1 = (mvIMPACT::acquire::Method *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Method_call" "', argument " "1"" of type '" "mvIMPACT::acquire::Method const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Method * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Method_call" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Method_call" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Method const *)arg1)->call((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_Method_call__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Method *arg1 = (mvIMPACT::acquire::Method *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  int result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Method_call" "', argument " "1"" of type '" "mvIMPACT::acquire::Method const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Method * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Method const *)arg1)->call(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Method_call(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "Method_call", 0, 3, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_Method_call__SWIG_3(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 2) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_Method_call__SWIG_0(self, argc, argv);}  check_2:
  if (argc == 2) { PyObject *retobj = _wrap_Method_call__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_Method_call__SWIG_1(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Method_call'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::Method::call(std::vector< std::string,std::allocator< std::string > > const &) const\n"
  "    mvIMPACT::acquire::Method::call(std::string const &,std::string const &) const\n"
  "    mvIMPACT::acquire::Method::call(std::string const &) const\n" "    mvIMPACT::acquire::Method::call() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_Method_paramList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Method *arg1 = (mvIMPACT::acquire::Method *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Method_paramList" "', argument " "1"" of type '" "mvIMPACT::acquire::Method const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Method * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Method const *)arg1)->paramList(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_Method(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Method *arg1 = (mvIMPACT::acquire::Method *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Method, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Method" "', argument " "1"" of type '" "mvIMPACT::acquire::Method *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Method * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *Method_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__Method, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Method_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Property__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::Property *)new mvIMPACT::acquire::Property();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Property__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ; mvIMPACT::acquire::Property *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Property" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Property *)new mvIMPACT::acquire::Property(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Property__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::Property *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__Property,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Property" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Property" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Property *)new mvIMPACT::acquire::Property((mvIMPACT::acquire::Property const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Property(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Property", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_Property__SWIG_0(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__Property, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_Property__SWIG_2(self, argc, argv);}  check_2:
  if (argc == 1) { PyObject *retobj = _wrap_new_Property__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Property'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Property::Property()\n"
  "    mvIMPACT::acquire::Property::Property(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::Property::Property(mvIMPACT::acquire::Property const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_Property_getAllowsValueCombinations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_getAllowsValueCombinations" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->allowsValueCombinations(); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_dictSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_dictSize" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Property const *)arg1)->dictSize(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_getHasDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_getHasDict" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->hasDict(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_getHasMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_getHasMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->hasMaxValue(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_getHasMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_getHasMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->hasMinValue(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_getHasStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_getHasStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->hasStepWidth(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_readS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; int arg2 ;
  std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int res3 = SWIG_OLDOBJ ;
  std::string result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_readS" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Property_readS" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Property_readS" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readS" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->readS(arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj;
  fail: if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_Property_readS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; int arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_readS" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Property_readS" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->readS(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_readS__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_readS" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->readS(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_readS(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "Property_readS", 0, 3, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_Property_readS__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_Property_readS__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_Property_readS__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Property_readS'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Property::readS(int,std::string const &) const\n"
  "    mvIMPACT::acquire::Property::readS(int) const\n" "    mvIMPACT::acquire::Property::readS() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_Property_readSArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; std::string *arg2 = 0 ;
  std::string *arg3 = 0 ; int arg4 ; int arg5 ; int arg6 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ;
  std::string result; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_readSArray" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Property_readSArray" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readSArray" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Property_readSArray" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Property_readSArray" "', argument " "5"" of type '" "int""'"); }  
  arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Property_readSArray" "', argument " "6"" of type '" "int""'"); }  
  arg6 = static_cast< int >(val6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_Property_readSArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; std::string *arg2 = 0 ;
  std::string *arg3 = 0 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; std::string result;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_readSArray" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Property_readSArray" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readSArray" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Property_readSArray" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Property_readSArray" "', argument " "5"" of type '" "int""'"); }  
  arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_Property_readSArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; std::string *arg2 = 0 ;
  std::string *arg3 = 0 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int res3 = SWIG_OLDOBJ ;
  int val4 ; int ecode4 = 0 ; std::string result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_readSArray" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Property_readSArray" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readSArray" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Property_readSArray" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2,(std::string const &)*arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_Property_readSArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; std::string *arg2 = 0 ;
  std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int res3 = SWIG_OLDOBJ ; std::string result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_readSArray" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Property_readSArray" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readSArray" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_Property_readSArray__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; std::string result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_readSArray" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_readSArray" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj;
  fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_Property_readSArray__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_readSArray" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_readSArray(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[7] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "Property_readSArray", 0, 6, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_Property_readSArray__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_Property_readSArray__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_Property_readSArray__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_Property_readSArray__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_Property_readSArray__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 6) {
    PyObject *retobj = _wrap_Property_readSArray__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Property_readSArray'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::Property::readSArray(std::string const &,std::string const &,int,int,int) const\n"
  "    mvIMPACT::acquire::Property::readSArray(std::string const &,std::string const &,int,int) const\n"
  "    mvIMPACT::acquire::Property::readSArray(std::string const &,std::string const &,int) const\n"
  "    mvIMPACT::acquire::Property::readSArray(std::string const &,std::string const &) const\n"
  "    mvIMPACT::acquire::Property::readSArray(std::string const &) const\n"
  "    mvIMPACT::acquire::Property::readSArray() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_Property_removeValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; int arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::Property *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_removeValue" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Property_removeValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->removeValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_removeValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::Property *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_removeValue" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->removeValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_removeValue(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "Property_removeValue", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_Property_removeValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_Property_removeValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Property_removeValue'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Property::removeValue(int) const\n"
  "    mvIMPACT::acquire::Property::removeValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_Property_resizeValArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::Property *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "Property_resizeValArray", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_resizeValArray" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Property_resizeValArray" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->resizeValArray(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_stringFormatString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_stringFormatString" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Property const *)arg1)->stringFormatString(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_valCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_valCount" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Property const *)arg1)->valCount(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_maxValCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_maxValCount" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Property const *)arg1)->maxValCount(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_writeS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; std::string *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::Property *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_writeS" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Property_writeS" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_writeS" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Property_writeS" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->writeS((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_Property_writeS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::Property *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_writeS" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Property_writeS" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_writeS" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->writeS((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_Property_writeS__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::Property *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_writeS" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Property_writeS" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->writeS((std::vector< std::string,std::allocator< std::string > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_Property_writeS__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::Property *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Property_writeS" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->writeS((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_Property_writeS(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "Property_writeS", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1; return _wrap_Property_writeS__SWIG_3(self, argc, argv);}
   check_1: if (argc == 2) { PyObject *retobj = _wrap_Property_writeS__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3;
    PyObject *retobj = _wrap_Property_writeS__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 3) {
    PyObject *retobj = _wrap_Property_writeS__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Property_writeS'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Property::writeS(std::string const &,int) const\n"
  "    mvIMPACT::acquire::Property::writeS(std::string const &) const\n"
  "    mvIMPACT::acquire::Property::writeS(std::vector< std::string,std::allocator< std::string > > const &,int) const\n"
  "    mvIMPACT::acquire::Property::writeS(std::vector< std::string,std::allocator< std::string > > const &) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_Property(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Property, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Property" "', argument " "1"" of type '" "mvIMPACT::acquire::Property *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *Property_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__Property, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Property_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::PropertyPtr *)new mvIMPACT::acquire::PropertyPtr();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::PropertyPtr *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyPtr" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyPtr *)new mvIMPACT::acquire::PropertyPtr(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyPtr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::PropertyPtr *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyPtr" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyPtr" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyPtr *)new mvIMPACT::acquire::PropertyPtr((mvIMPACT::acquire::PropertyPtr const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyPtr(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyPtr", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyPtr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyPtr__SWIG_2(self, argc, argv);}  check_2:
  if (argc == 1) { PyObject *retobj = _wrap_new_PropertyPtr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyPtr'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyPtr::PropertyPtr()\n"
  "    mvIMPACT::acquire::PropertyPtr::PropertyPtr(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::PropertyPtr::PropertyPtr(mvIMPACT::acquire::PropertyPtr const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; void *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyPtr_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (void *)((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 ); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyPtr_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (void *)((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 ); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< void *,std::allocator< void * > > *arg2 = 0 ; int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyPtr_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_void_p_std__allocatorT_void_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > &""'"); }
   arg2 = reinterpret_cast< std::vector< void *,std::allocator< void * > > * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyPtr_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyPtr_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(*arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< void *,std::allocator< void * > > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyPtr_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_void_p_std__allocatorT_void_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > &""'"); }
   arg2 = reinterpret_cast< std::vector< void *,std::allocator< void * > > * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyPtr_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(*arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< void *,std::allocator< void * > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyPtr_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_void_p_std__allocatorT_void_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > &""'"); }
   arg2 = reinterpret_cast< std::vector< void *,std::allocator< void * > > * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyPtr_read", 0, 4, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyPtr_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_void_p_std__allocatorT_void_p_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_PropertyPtr_read__SWIG_4(self, argc, argv);}  check_2:
  if (argc == 2) { PyObject *retobj = _wrap_PropertyPtr_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_PropertyPtr_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyPtr_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyPtr_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyPtr::read(int) const\n"
  "    mvIMPACT::acquire::PropertyPtr::read() const\n"
  "    mvIMPACT::acquire::PropertyPtr::read(std::vector< void *,std::allocator< void * > > &,int,int) const\n"
  "    mvIMPACT::acquire::PropertyPtr::read(std::vector< void *,std::allocator< void * > > &,int) const\n"
  "    mvIMPACT::acquire::PropertyPtr::read(std::vector< void *,std::allocator< void * > > &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyPtr_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  void *arg2 = (void *) 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::PropertyPtr *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyPtr_write" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "void *""'");  } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyPtr_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyPtr *) &((mvIMPACT::acquire::PropertyPtr const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  void *arg2 = (void *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; mvIMPACT::acquire::PropertyPtr *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyPtr_write" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "void *""'");  } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyPtr *) &((mvIMPACT::acquire::PropertyPtr const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< void *,std::allocator< void * > > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::PropertyPtr *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyPtr_write" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_void_p_std__allocatorT_void_p_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > const &""'"); }
   arg2 = reinterpret_cast< std::vector< void *,std::allocator< void * > > * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyPtr_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyPtr *) &((mvIMPACT::acquire::PropertyPtr const *)arg1)->write((std::vector< void *,std::allocator< void * > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< void *,std::allocator< void * > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  mvIMPACT::acquire::PropertyPtr *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyPtr_write" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_void_p_std__allocatorT_void_p_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "std::vector< void *,std::allocator< void * > > const &""'"); }
   arg2 = reinterpret_cast< std::vector< void *,std::allocator< void * > > * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyPtr *) &((mvIMPACT::acquire::PropertyPtr const *)arg1)->write((std::vector< void *,std::allocator< void * > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyPtr_write", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_void_p_std__allocatorT_void_p_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; return _wrap_PropertyPtr_write__SWIG_3(self, argc, argv);}  check_1:
  if (argc == 2) { PyObject *retobj = _wrap_PropertyPtr_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_void_p_std__allocatorT_void_p_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_3; PyObject *retobj = _wrap_PropertyPtr_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyPtr_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyPtr_write'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyPtr::write(void *,int) const\n"
  "    mvIMPACT::acquire::PropertyPtr::write(void *) const\n"
  "    mvIMPACT::acquire::PropertyPtr::write(std::vector< void *,std::allocator< void * > > const &,int) const\n"
  "    mvIMPACT::acquire::PropertyPtr::write(std::vector< void *,std::allocator< void * > > const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyPtr" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyPtr *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyPtr * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyPtr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::PropertyS *)new mvIMPACT::acquire::PropertyS();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ; mvIMPACT::acquire::PropertyS *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyS" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyS *)new mvIMPACT::acquire::PropertyS(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyS__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__PropertyS,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyS" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyS" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyS *)new mvIMPACT::acquire::PropertyS((mvIMPACT::acquire::PropertyS const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyS(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyS", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyS__SWIG_0(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__PropertyS, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyS__SWIG_2(self, argc, argv);}  check_2:
  if (argc == 1) { PyObject *retobj = _wrap_new_PropertyS__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyS'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyS::PropertyS()\n"
  "    mvIMPACT::acquire::PropertyS::PropertyS(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::PropertyS::PropertyS(mvIMPACT::acquire::PropertyS const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyS_binaryDataBufferSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; unsigned int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_binaryDataBufferSize" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyS_binaryDataBufferSize" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::PropertyS const *)arg1)->binaryDataBufferSize(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_binaryDataBufferSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; unsigned int result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_binaryDataBufferSize" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::PropertyS const *)arg1)->binaryDataBufferSize();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_binaryDataBufferSize(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyS_binaryDataBufferSize", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyS_binaryDataBufferSize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyS_binaryDataBufferSize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyS_binaryDataBufferSize'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyS::binaryDataBufferSize(int) const\n"
  "    mvIMPACT::acquire::PropertyS::binaryDataBufferSize() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyS_binaryDataBufferMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_binaryDataBufferMaxSize" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::PropertyS const *)arg1)->binaryDataBufferMaxSize();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyS_read" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::PropertyS const *)arg1)->read(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::PropertyS const *)arg1)->read(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ;
  int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyS_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::PropertyS const *)arg1)->read(*arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::PropertyS const *)arg1)->read(*arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_read" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::PropertyS const *)arg1)->read(*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyS_read", 0, 4, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyS_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2; return _wrap_PropertyS_read__SWIG_4(self, argc, argv);}
   check_2: if (argc == 2) { PyObject *retobj = _wrap_PropertyS_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_PropertyS_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyS_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyS_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyS::read(int) const\n"
  "    mvIMPACT::acquire::PropertyS::read() const\n"
  "    mvIMPACT::acquire::PropertyS::read(std::vector< std::string,std::allocator< std::string > > &,int,int) const\n"
  "    mvIMPACT::acquire::PropertyS::read(std::vector< std::string,std::allocator< std::string > > &,int) const\n"
  "    mvIMPACT::acquire::PropertyS::read(std::vector< std::string,std::allocator< std::string > > &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyS_readBinary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; int arg2 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; bool val3 ; int ecode3 = 0 ; std::string result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_readBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyS_readBinary" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_readBinary" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::PropertyS const *)arg1)->readBinary(arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_readBinary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_readBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyS_readBinary" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::PropertyS const *)arg1)->readBinary(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_readBinary__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_readBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::PropertyS const *)arg1)->readBinary(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; std::string *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_write" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_write" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyS_write" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->write((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::PropertyS *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_write" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_write" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyS_write" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->write((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::PropertyS *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_write" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->write((std::vector< std::string,std::allocator< std::string > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_write" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->write((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyS_write", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1; return _wrap_PropertyS_write__SWIG_3(self, argc, argv);}
   check_1: if (argc == 2) { PyObject *retobj = _wrap_PropertyS_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3;
    PyObject *retobj = _wrap_PropertyS_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyS_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyS_write'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyS::write(std::string const &,int) const\n"
  "    mvIMPACT::acquire::PropertyS::write(std::string const &) const\n"
  "    mvIMPACT::acquire::PropertyS::write(std::vector< std::string,std::allocator< std::string > > const &,int) const\n"
  "    mvIMPACT::acquire::PropertyS::write(std::vector< std::string,std::allocator< std::string > > const &) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyS_writeBinary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; std::string *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_writeBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_writeBinary" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyS_writeBinary" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_writeBinary" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->writeBinary((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_writeBinary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::PropertyS *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_writeBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_writeBinary" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyS_writeBinary" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->writeBinary((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_readBinary__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; char *arg2 = (char *) 0 ;
  int arg3 ; int arg4 ; bool arg5 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; bool val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_readBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_readBinary" "', argument " "2"" of type '" "char *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_readBinary" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyS_readBinary" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyS_readBinary" "', argument " "5"" of type '" "bool""'"); }
    arg5 = static_cast< bool >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT_acquire_PropertyS_readBinary__SWIG_3((mvIMPACT::acquire::PropertyS const *)arg1,arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_readBinary__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; char *arg2 = (char *) 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_readBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_readBinary" "', argument " "2"" of type '" "char *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_readBinary" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyS_readBinary" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT_acquire_PropertyS_readBinary__SWIG_3((mvIMPACT::acquire::PropertyS const *)arg1,arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_readBinary__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; char *arg2 = (char *) 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; int ecode3 = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_readBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_readBinary" "', argument " "2"" of type '" "char *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_readBinary" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT_acquire_PropertyS_readBinary__SWIG_3((mvIMPACT::acquire::PropertyS const *)arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_readBinary(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyS_readBinary", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyS_readBinary__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyS_readBinary__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[1], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyS_readBinary__SWIG_0(self, argc, argv);}  check_3: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyS_readBinary__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyS_readBinary__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyS_readBinary__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyS_readBinary'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyS::readBinary(int,bool) const\n"
  "    mvIMPACT::acquire::PropertyS::readBinary(int) const\n" "    mvIMPACT::acquire::PropertyS::readBinary() const\n"
  "    mvIMPACT::acquire::PropertyS::readBinary(char *,int,int,bool) const\n"
  "    mvIMPACT::acquire::PropertyS::readBinary(char *,int,int) const\n"
  "    mvIMPACT::acquire::PropertyS::readBinary(char *,int) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyS_writeBinary__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; char *arg2 = (char *) 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_writeBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_writeBinary" "', argument " "2"" of type '" "char const *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_writeBinary" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyS_writeBinary" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT_acquire_PropertyS_writeBinary__SWIG_2((mvIMPACT::acquire::PropertyS const *)arg1,(char const *)arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_writeBinary__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; char *arg2 = (char *) 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; int ecode3 = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyS_writeBinary" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_writeBinary" "', argument " "2"" of type '" "char const *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyS_writeBinary" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT_acquire_PropertyS_writeBinary__SWIG_2((mvIMPACT::acquire::PropertyS const *)arg1,(char const *)arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_writeBinary(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyS_writeBinary", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_PropertyS_writeBinary__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    PyObject *retobj = _wrap_PropertyS_writeBinary__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_2: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyS_writeBinary__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyS_writeBinary__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyS_writeBinary'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyS::writeBinary(std::string const &,int) const\n"
  "    mvIMPACT::acquire::PropertyS::writeBinary(std::string const &) const\n"
  "    mvIMPACT::acquire::PropertyS::writeBinary(char const *,int,int) const\n"
  "    mvIMPACT::acquire::PropertyS::writeBinary(char const *,int) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PropertyS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyS" "', argument " "1"" of type '" "mvIMPACT::acquire::PropertyS *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PropertyS * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__PropertyS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_UserDataEntry_getUDEIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::UserDataEntry *arg1 = (mvIMPACT::acquire::UserDataEntry *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserDataEntry_getUDEIsValid" "', argument " "1"" of type '" "mvIMPACT::acquire::UserDataEntry const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserDataEntry * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::UserDataEntry const *)arg1)->isValid(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserDataEntry_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserDataEntry *arg1 = (mvIMPACT::acquire::UserDataEntry *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserDataEntry_name_get" "', argument " "1"" of type '" "mvIMPACT::acquire::UserDataEntry *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserDataEntry * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->name); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserDataEntry_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserDataEntry *arg1 = (mvIMPACT::acquire::UserDataEntry *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserDataEntry_data_get" "', argument " "1"" of type '" "mvIMPACT::acquire::UserDataEntry *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserDataEntry * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->data); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserDataEntry_access_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserDataEntry *arg1 = (mvIMPACT::acquire::UserDataEntry *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIUserDataAccessRight *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserDataEntry_access_get" "', argument " "1"" of type '" "mvIMPACT::acquire::UserDataEntry *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserDataEntry * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIUserDataAccessRight *)& ((arg1)->access); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserDataEntry_password_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserDataEntry *arg1 = (mvIMPACT::acquire::UserDataEntry *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserDataEntry_password_get" "', argument " "1"" of type '" "mvIMPACT::acquire::UserDataEntry *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserDataEntry * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->password); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_UserDataEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserDataEntry *arg1 = (mvIMPACT::acquire::UserDataEntry *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UserDataEntry" "', argument " "1"" of type '" "mvIMPACT::acquire::UserDataEntry *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserDataEntry * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *UserDataEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_UserData_createEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; SwigValueWrapper< mvIMPACT::acquire::UserDataEntry > result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_createEntry" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->createEntry(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::UserDataEntry(static_cast< const mvIMPACT::acquire::UserDataEntry& >(result))), SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserData_deleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; mvIMPACT::acquire::UserDataEntry *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "UserData_deleteEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_deleteEntry" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserData_deleteEntry" "', argument " "2"" of type '" "mvIMPACT::acquire::UserDataEntry &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserData_deleteEntry" "', argument " "2"" of type '" "mvIMPACT::acquire::UserDataEntry &""'"); }
   arg2 = reinterpret_cast< mvIMPACT::acquire::UserDataEntry * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->deleteEntry(*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserData_getFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_getFreeMemory" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::UserData const *)arg1)->getFreeMemory(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserData_getUserDataEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; PyObject *swig_obj[2] ; SwigValueWrapper< mvIMPACT::acquire::UserDataEntry > result;
  if (!SWIG_Python_UnpackTuple(args, "UserData_getUserDataEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_getUserDataEntry" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserData_getUserDataEntry" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::UserData const *)arg1)->getUserDataEntry(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::UserDataEntry(static_cast< const mvIMPACT::acquire::UserDataEntry& >(result))), SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserData_validUserDataEntryIndexes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "UserData_validUserDataEntryIndexes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_validUserDataEntryIndexes" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  int lsize = PySequence_Length(swig_obj[1]);
    std::vector<int>* pV = new std::vector<int> (0); for( int i = 0; i < lsize; ++i ) {
      PyObject* objectValue = PyList_GetItem(swig_obj[1], i); if ( NULL == objectValue ) { SWIG_fail; } 
      PyErr_Restore(NULL, NULL, NULL);  int value = PyLong_AsLong(objectValue); if ( NULL != PyErr_Occurred() ) { SWIG_fail; } 
      pV->push_back(static_cast<int>(value)); }  arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::UserData const *)arg1)->validUserDataEntryIndexes(*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int>::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_UserData_getIsAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_getIsAvailable" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::UserData const *)arg1)->isAvailable(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserData_writeToHardware(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_writeToHardware" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::UserData const *)arg1)->writeToHardware(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserData_reconnectBehaviour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIUserDataReconnectBehaviour *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_reconnectBehaviour_get" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIUserDataReconnectBehaviour *)& ((arg1)->reconnectBehaviour);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserData_memoryAvailable_bytes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_memoryAvailable_bytes_get" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->memoryAvailable_bytes); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserData_memoryConsumed_bytes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserData_memoryConsumed_bytes_get" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->memoryConsumed_bytes); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_UserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::UserData *arg1 = (mvIMPACT::acquire::UserData *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__UserData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UserData" "', argument " "1"" of type '" "mvIMPACT::acquire::UserData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::UserData * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *UserData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__UserData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Device(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::Device *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__Device,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Device" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)new mvIMPACT::acquire::Device((mvIMPACT::acquire::Device const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_Device(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Device" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_close" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->close();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_hasCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; mvIMPACT::acquire::TDeviceCapability arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "Device_hasCapability", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_hasCapability" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Device_hasCapability" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceCapability""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceCapability >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Device const *)arg1)->hasCapability(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_hasValidLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_hasValidLicense" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Device const *)arg1)->hasValidLicense(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_hDev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::HDEV result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_hDev" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HDEV)((mvIMPACT::acquire::Device const *)arg1)->hDev(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_hDrv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::HDRV result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_hDrv" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HDRV)((mvIMPACT::acquire::Device const *)arg1)->hDrv(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_deviceDriverFeatureList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::ComponentList result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_deviceDriverFeatureList" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Device const *)arg1)->deviceDriverFeatureList(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::ComponentList(static_cast< const mvIMPACT::acquire::ComponentList& >(result))), SWIGTYPE_p_mvIMPACT__acquire__ComponentList, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_getIsOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_getIsOpen" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Device const *)arg1)->isOpen(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_getIsInUse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_getIsInUse" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Device const *)arg1)->isInUse(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_open" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->open();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_setID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; PyObject *swig_obj[2] ; int result;
  if (!SWIG_Python_UnpackTuple(args, "Device_setID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_setID" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Device_setID" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Device const *)arg1)->setID(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_updateFirmware(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_updateFirmware" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Device const *)arg1)->updateFirmware(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_getUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::UserData *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_getUserData" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::UserData *) &(arg1)->getUserData(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__UserData, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_validateInterfaceLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ;
  mvIMPACT::acquire::TDeviceInterfaceLayout arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ; if (!SWIG_Python_UnpackTuple(args, "Device_validateInterfaceLayout", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_validateInterfaceLayout" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Device_validateInterfaceLayout" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceInterfaceLayout""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceInterfaceLayout >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::Device const *)arg1)->validateInterfaceLayout(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_deviceClass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIDeviceClass *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_deviceClass_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceClass *)& ((arg1)->deviceClass); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_family_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_family_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->family); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_product_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_product_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->product); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_capabilities_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIDeviceCapability *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_capabilities_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceCapability *)& ((arg1)->capabilities); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_serial_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_serial_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->serial); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIDeviceState *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_state_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceState *)& ((arg1)->state); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_deviceID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_deviceID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->deviceID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_deviceVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_deviceVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_firmwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_firmwareVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->firmwareVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_loadSettings_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIDeviceLoadSettings *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_loadSettings_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceLoadSettings *)& ((arg1)->loadSettings); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_autoLoadSettingOrder_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_autoLoadSettingOrder_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->autoLoadSettingOrder); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_interfaceLayout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIDeviceInterfaceLayout *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_interfaceLayout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceInterfaceLayout *)& ((arg1)->interfaceLayout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_customDataDirectory_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_customDataDirectory_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->customDataDirectory); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_defaultRequestCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_defaultRequestCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->defaultRequestCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_resultQueueCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_resultQueueCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->resultQueueCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_userControlledImageProcessingEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_userControlledImageProcessingEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->userControlledImageProcessingEnable);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_allowUnrecommendedFeatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_allowUnrecommendedFeatures_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->allowUnrecommendedFeatures); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_acquisitionStartStopBehaviour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAcquisitionStartStopBehaviour *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_acquisitionStartStopBehaviour_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAcquisitionStartStopBehaviour *)& ((arg1)->acquisitionStartStopBehaviour);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_HWUpdateResult_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIHWUpdateResult *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_HWUpdateResult_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIHWUpdateResult *)& ((arg1)->HWUpdateResult); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_manufacturer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_manufacturer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->manufacturer); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_manufacturerSpecificInformation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_manufacturerSpecificInformation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->manufacturerSpecificInformation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_desiredAccess_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIDeviceAccessMode *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_desiredAccess_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceAccessMode *)& ((arg1)->desiredAccess); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_grantedAccess_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIDeviceAccessMode *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_grantedAccess_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceAccessMode *)& ((arg1)->grantedAccess); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_autoNegotiatePacketSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_autoNegotiatePacketSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->autoNegotiatePacketSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_autoNegotiatePacketSizeMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDeviceAutoNegotiatePacketSizeMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_autoNegotiatePacketSizeMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceAutoNegotiatePacketSizeMode *)& ((arg1)->autoNegotiatePacketSizeMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAutoNegotiatePacketSizeMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_licenseValid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_licenseValid_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->licenseValid); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_licenseDetails_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_licenseDetails_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->licenseDetails); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *Device_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__Device, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Device_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DeviceManager__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::DeviceManager *)new mvIMPACT::acquire::DeviceManager();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceManager__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::DeviceManager *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__DeviceManager,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeviceManager" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeviceManager" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::DeviceManager *)new mvIMPACT::acquire::DeviceManager((mvIMPACT::acquire::DeviceManager const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceManager(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DeviceManager", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_DeviceManager__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_DeviceManager__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DeviceManager'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::DeviceManager::DeviceManager()\n"
  "    mvIMPACT::acquire::DeviceManager::DeviceManager(mvIMPACT::acquire::DeviceManager const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_DeviceManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeviceManager" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getVersionAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TLibraryQuery arg1 ; int val1 ; int ecode1 = 0 ; PyObject *swig_obj[1] ;
  std::string result; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DeviceManager_getVersionAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::TLibraryQuery""'"); }
    arg1 = static_cast< mvIMPACT::acquire::TLibraryQuery >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = mvIMPACT::acquire::DeviceManager::getVersionAsString(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getInternalHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::HDMR result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getInternalHandle" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HDMR)((mvIMPACT::acquire::DeviceManager const *)arg1)->getInternalHandle();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_changedCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_changedCount" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::DeviceManager const *)arg1)->changedCount(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_deviceCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_deviceCount" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::DeviceManager const *)arg1)->deviceCount(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_updateDeviceList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_updateDeviceList" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::DeviceManager const *)arg1)->updateDeviceList(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; unsigned int arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::Device *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "DeviceManager_getDevice", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DeviceManager_getDevice" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDevice(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceBySerial__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; unsigned int arg3 ; char arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ; int ecode3 = 0 ; char val4 ; int ecode4 = 0 ; mvIMPACT::acquire::Device *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceBySerial" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); ecode4 = SWIG_AsVal_char(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "4"" of type '" "char""'"); }
    arg4 = static_cast< char >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceBySerial((std::string const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceBySerial__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; unsigned int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::Device *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceBySerial" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceBySerial((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceBySerial__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::Device *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceBySerial" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceBySerial((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceBySerial__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::Device *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceBySerial" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceBySerial();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceBySerial(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "DeviceManager_getDeviceBySerial", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_DeviceManager_getDeviceBySerial__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceBySerial__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceBySerial__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceBySerial__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DeviceManager_getDeviceBySerial'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceBySerial(std::string const &,unsigned int,char) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceBySerial(std::string const &,unsigned int) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceBySerial(std::string const &) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceBySerial() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByFamily__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; unsigned int arg3 ; char arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ; int ecode3 = 0 ; char val4 ; int ecode4 = 0 ; mvIMPACT::acquire::Device *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByFamily" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); ecode4 = SWIG_AsVal_char(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "4"" of type '" "char""'"); }
    arg4 = static_cast< char >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByFamily((std::string const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByFamily__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; unsigned int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::Device *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByFamily" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByFamily((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByFamily__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::Device *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByFamily" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByFamily((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByFamily__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::Device *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByFamily" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByFamily();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByFamily(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "DeviceManager_getDeviceByFamily", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_DeviceManager_getDeviceByFamily__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceByFamily__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceByFamily__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceByFamily__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DeviceManager_getDeviceByFamily'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByFamily(std::string const &,unsigned int,char) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByFamily(std::string const &,unsigned int) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByFamily(std::string const &) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByFamily() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; unsigned int arg3 ; char arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ; int ecode3 = 0 ; char val4 ; int ecode4 = 0 ; mvIMPACT::acquire::Device *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProduct" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); ecode4 = SWIG_AsVal_char(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "4"" of type '" "char""'"); }
    arg4 = static_cast< char >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProduct((std::string const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; unsigned int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::Device *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProduct" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProduct((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProduct__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::Device *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProduct" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProduct((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProduct__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::Device *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProduct" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProduct();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProduct(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "DeviceManager_getDeviceByProduct", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_DeviceManager_getDeviceByProduct__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceByProduct__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceByProduct__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceByProduct__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DeviceManager_getDeviceByProduct'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProduct(std::string const &,unsigned int,char) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProduct(std::string const &,unsigned int) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProduct(std::string const &) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProduct() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProductAndID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; unsigned int arg3 ; char arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ; int ecode3 = 0 ; char val4 ; int ecode4 = 0 ; mvIMPACT::acquire::Device *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); ecode4 = SWIG_AsVal_char(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "4"" of type '" "char""'"); }
    arg4 = static_cast< char >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProductAndID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; unsigned int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::Device *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProductAndID__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::Device *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProductAndID__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::Device *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProductAndID__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; std::string *arg3 = 0 ; char arg4 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ; char val4 ; int ecode4 = 0 ; mvIMPACT::acquire::Device *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  ecode4 = SWIG_AsVal_char(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "4"" of type '" "char""'"); }
    arg4 = static_cast< char >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2,(std::string const &)*arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProductAndID__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ;
  std::string *arg2 = 0 ; std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ; mvIMPACT::acquire::Device *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceManager_getDeviceByProductAndID" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProductAndID(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "DeviceManager_getDeviceByProductAndID", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_DeviceManager_getDeviceByProductAndID__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceByProductAndID__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_DeviceManager_getDeviceByProductAndID__SWIG_1(self, argc, argv);}  check_3: if (argc == 3) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceByProductAndID__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_5;
    PyObject *retobj = _wrap_DeviceManager_getDeviceByProductAndID__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_5: if (argc == 4) {
    PyObject *retobj = _wrap_DeviceManager_getDeviceByProductAndID__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DeviceManager_getDeviceByProductAndID'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID(std::string const &,unsigned int,char) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID(std::string const &,unsigned int) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID(std::string const &) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID() const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID(std::string const &,std::string const &,char) const\n"
  "    mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID(std::string const &,std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_DeviceManager_closeAllDevices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager_closeAllDevices" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT_acquire_DeviceManager_closeAllDevices(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DeviceManager *arg1 = (mvIMPACT::acquire::DeviceManager *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::Device *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "DeviceManager___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceManager___getitem__" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceManager * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DeviceManager___getitem__" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Device *)mvIMPACT_acquire_DeviceManager___getitem__(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *DeviceManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__DeviceManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DeviceManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DeviceComponentLocator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceComponentLocator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceComponentLocator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HLIST arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::DeviceComponentLocator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DeviceComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::HLIST""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HLIST >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceComponentLocator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HLIST arg1 ; std::string *arg2 = 0 ; int val1 ; int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::DeviceComponentLocator *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DeviceComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::HLIST""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HLIST >(val1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DeviceComponentLocator" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeviceComponentLocator" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceComponentLocator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ;
  mvIMPACT::acquire::TDeviceListType arg2 ; std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ; mvIMPACT::acquire::DeviceComponentLocator *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeviceComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DeviceComponentLocator" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceListType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceListType >(val2); { std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DeviceComponentLocator" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeviceComponentLocator" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator(arg1,arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceComponentLocator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ;
  mvIMPACT::acquire::TDeviceListType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::DeviceComponentLocator *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeviceComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DeviceComponentLocator" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceListType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceListType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceComponentLocator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_DeviceComponentLocator", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_DeviceComponentLocator__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_DeviceComponentLocator__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Device, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[1], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_new_DeviceComponentLocator__SWIG_4(self, argc, argv);}  check_3: if (argc == 2) {
    PyObject *retobj = _wrap_new_DeviceComponentLocator__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_DeviceComponentLocator__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DeviceComponentLocator'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::DeviceComponentLocator::DeviceComponentLocator()\n"
  "    mvIMPACT::acquire::DeviceComponentLocator::DeviceComponentLocator(mvIMPACT::acquire::HLIST)\n"
  "    mvIMPACT::acquire::DeviceComponentLocator::DeviceComponentLocator(mvIMPACT::acquire::HLIST,std::string const &)\n"
  "    mvIMPACT::acquire::DeviceComponentLocator::DeviceComponentLocator(mvIMPACT::acquire::Device *,mvIMPACT::acquire::TDeviceListType,std::string const &)\n"
  "    mvIMPACT::acquire::DeviceComponentLocator::DeviceComponentLocator(mvIMPACT::acquire::Device *,mvIMPACT::acquire::TDeviceListType)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_DeviceComponentLocator_bindSearchBaseList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceComponentLocator *arg1 = (mvIMPACT::acquire::DeviceComponentLocator *) 0 ;
  mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ; mvIMPACT::acquire::TDeviceListType arg3 ;
  std::string *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ; mvIMPACT::acquire::HLIST result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceComponentLocator_bindSearchBaseList" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceComponentLocator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceComponentLocator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceComponentLocator_bindSearchBaseList" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceComponentLocator_bindSearchBaseList" "', argument " "3"" of type '" "mvIMPACT::acquire::TDeviceListType""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDeviceListType >(val3); { std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DeviceComponentLocator_bindSearchBaseList" "', argument " "4"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceComponentLocator_bindSearchBaseList" "', argument " "4"" of type '" "std::string const &""'"); }
     arg4 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HLIST)(arg1)->bindSearchBaseList(arg2,arg3,(std::string const &)*arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res4)) delete arg4; return resultobj; fail:
  if (SWIG_IsNewObj(res4)) delete arg4; return NULL; }
SWIGINTERN PyObject *_wrap_DeviceComponentLocator_bindSearchBaseList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceComponentLocator *arg1 = (mvIMPACT::acquire::DeviceComponentLocator *) 0 ;
  mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ; mvIMPACT::acquire::TDeviceListType arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::HLIST result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceComponentLocator_bindSearchBaseList" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceComponentLocator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceComponentLocator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceComponentLocator_bindSearchBaseList" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DeviceComponentLocator_bindSearchBaseList" "', argument " "3"" of type '" "mvIMPACT::acquire::TDeviceListType""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDeviceListType >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HLIST)(arg1)->bindSearchBaseList(arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceComponentLocator_bindSearchBaseList(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "DeviceComponentLocator_bindSearchBaseList", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 3) { PyObject *retobj = _wrap_DeviceComponentLocator_bindSearchBaseList__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_DeviceComponentLocator_bindSearchBaseList__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DeviceComponentLocator_bindSearchBaseList'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::DeviceComponentLocator::bindSearchBaseList(mvIMPACT::acquire::Device *,mvIMPACT::acquire::TDeviceListType,std::string const &)\n"
  "    mvIMPACT::acquire::DeviceComponentLocator::bindSearchBaseList(mvIMPACT::acquire::Device *,mvIMPACT::acquire::TDeviceListType)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_DeviceComponentLocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceComponentLocator *arg1 = (mvIMPACT::acquire::DeviceComponentLocator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeviceComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::DeviceComponentLocator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DeviceComponentLocator * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *DeviceComponentLocator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DeviceComponentLocator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ImageBufferDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageBufferDesc *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ImageBufferDesc *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageBufferDesc" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBufferDesc const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageBufferDesc" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBufferDesc const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBufferDesc * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc((mvIMPACT::acquire::ImageBufferDesc const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageBufferDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; int arg1 ; int val1 ; int ecode1 = 0 ; mvIMPACT::acquire::ImageBufferDesc *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageBufferDesc" "', argument " "1"" of type '" "int""'"); }  
  arg1 = static_cast< int >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageBufferDesc__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TImageBufferPixelFormat arg1 ; int arg2 ; int arg3 ; int val1 ; int ecode1 = 0 ;
  int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::ImageBufferDesc *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageBufferDesc" "', argument " "1"" of type '" "mvIMPACT::acquire::TImageBufferPixelFormat""'"); }
    arg1 = static_cast< mvIMPACT::acquire::TImageBufferPixelFormat >(val1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageBufferDesc" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageBufferDesc" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc(arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageBufferDesc__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; mvIMPACT::acquire::TImageFileFormat arg2 ; int res1 = SWIG_OLDOBJ ;
  int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::ImageBufferDesc *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageBufferDesc" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageBufferDesc" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageBufferDesc" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageFileFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageFileFormat >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc((std::string const &)*arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageBufferDesc__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; mvIMPACT::acquire::ImageBufferDesc *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageBufferDesc" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageBufferDesc" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageBufferDesc(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ImageBufferDesc", 0, 3, argv))) SWIG_fail; --argc; if (argc == 1) {
    int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; return _wrap_new_ImageBufferDesc__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 1) { int _v = 0; { { int res = SWIG_AsVal_int(argv[0], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_2; return _wrap_new_ImageBufferDesc__SWIG_1(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_ImageBufferDesc__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ImageBufferDesc__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_ImageBufferDesc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ImageBufferDesc'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ImageBufferDesc::ImageBufferDesc(mvIMPACT::acquire::ImageBufferDesc const &)\n"
  "    mvIMPACT::acquire::ImageBufferDesc::ImageBufferDesc(int)\n"
  "    mvIMPACT::acquire::ImageBufferDesc::ImageBufferDesc(mvIMPACT::acquire::TImageBufferPixelFormat,int,int)\n"
  "    mvIMPACT::acquire::ImageBufferDesc::ImageBufferDesc(std::string const &,mvIMPACT::acquire::TImageFileFormat)\n"
  "    mvIMPACT::acquire::ImageBufferDesc::ImageBufferDesc(std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ImageBufferDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBufferDesc *arg1 = (mvIMPACT::acquire::ImageBufferDesc *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageBufferDesc" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBufferDesc *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBufferDesc * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBufferDesc_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBufferDesc *arg1 = (mvIMPACT::acquire::ImageBufferDesc *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; SwigValueWrapper< mvIMPACT::acquire::ImageBufferDesc > result; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBufferDesc_clone" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBufferDesc const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBufferDesc * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::ImageBufferDesc const *)arg1)->clone(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::ImageBufferDesc(static_cast< const mvIMPACT::acquire::ImageBufferDesc& >(result))), SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBufferDesc_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBufferDesc *arg1 = (mvIMPACT::acquire::ImageBufferDesc *) 0 ; char *arg2 = (char *) 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; int ecode3 = 0 ;
  PyObject *swig_obj[3] ; int result; if (!SWIG_Python_UnpackTuple(args, "ImageBufferDesc_copy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBufferDesc_copy" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBufferDesc const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBufferDesc * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageBufferDesc_copy" "', argument " "2"" of type '" "char *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageBufferDesc_copy" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::ImageBufferDesc const *)arg1)->copy(arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; }
SWIGINTERN PyObject *_wrap_ImageBufferDesc_getBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageBufferDesc *arg1 = (mvIMPACT::acquire::ImageBufferDesc *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::ImageBuffer *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBufferDesc_getBuffer" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBufferDesc const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBufferDesc * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageBuffer *)((mvIMPACT::acquire::ImageBufferDesc const *)arg1)->getBuffer();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageBufferDesc_save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageBufferDesc *arg1 = (mvIMPACT::acquire::ImageBufferDesc *) 0 ;
  std::string *arg2 = 0 ; mvIMPACT::acquire::TImageFileFormat arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int val3 ; int ecode3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBufferDesc_save" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBufferDesc const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBufferDesc * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageBufferDesc_save" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageBufferDesc_save" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageBufferDesc_save" "', argument " "3"" of type '" "mvIMPACT::acquire::TImageFileFormat""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TImageFileFormat >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::ImageBufferDesc const *)arg1)->save((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_ImageBufferDesc_save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageBufferDesc *arg1 = (mvIMPACT::acquire::ImageBufferDesc *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageBufferDesc_save" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageBufferDesc const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageBufferDesc * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageBufferDesc_save" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageBufferDesc_save" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::ImageBufferDesc const *)arg1)->save((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_ImageBufferDesc_save(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "ImageBufferDesc_save", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_ImageBufferDesc_save__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_ImageBufferDesc_save__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ImageBufferDesc_save'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ImageBufferDesc::save(std::string const &,mvIMPACT::acquire::TImageFileFormat) const\n"
  "    mvIMPACT::acquire::ImageBufferDesc::save(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *ImageBufferDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImageBufferDesc_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_ComponentCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentCollection *arg1 = (mvIMPACT::acquire::ComponentCollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentCollection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComponentCollection" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCollection *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCollection * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentCollection_hObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ComponentCollection *arg1 = (mvIMPACT::acquire::ComponentCollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::HOBJ result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentCollection_hObj" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCollection const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCollection * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentCollection const *)arg1)->hObj();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentCollection_restoreDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentCollection *arg1 = (mvIMPACT::acquire::ComponentCollection *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::ComponentCollection *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ComponentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComponentCollection_restoreDefault" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCollection const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCollection * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ComponentCollection *) &((mvIMPACT::acquire::ComponentCollection const *)arg1)->restoreDefault();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ComponentCollection, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ComponentCollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ComponentCollection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_BufferPart_getImageBufferDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::ImageBufferDesc *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_getImageBufferDesc" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageBufferDesc *) &((mvIMPACT::acquire::BufferPart const *)arg1)->getImageBufferDesc();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_address_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyPtr *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_address_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyPtr *)& ((arg1)->address); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_dataSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_dataSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->dataSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_dataType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64BufferPartDataType *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_dataType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64BufferPartDataType *)& ((arg1)->dataType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_pixelFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIImageBufferPixelFormat *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_pixelFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIImageBufferPixelFormat *)& ((arg1)->pixelFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_width_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->width); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_height_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->height); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_offsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_offsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->offsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_offsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_offsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->offsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_paddingX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_paddingX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->paddingX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_bytesPerPixel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_bytesPerPixel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->bytesPerPixel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_bayerMosaicParity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBayerMosaicParity *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_bayerMosaicParity_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBayerMosaicParity *)& ((arg1)->bayerMosaicParity); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_channelCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_channelCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->channelCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_channelDesc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_channelDesc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->channelDesc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_pixelPitch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_pixelPitch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->pixelPitch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_linePitch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_linePitch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->linePitch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_channelBitDepth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_channelBitDepth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->channelBitDepth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_channelOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_channelOffset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->channelOffset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_sourceID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_sourceID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sourceID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_regionID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_regionID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->regionID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BufferPart_groupID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferPart_groupID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->groupID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_BufferPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BufferPart *arg1 = (mvIMPACT::acquire::BufferPart *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BufferPart, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BufferPart" "', argument " "1"" of type '" "mvIMPACT::acquire::BufferPart *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BufferPart * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *BufferPart_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__BufferPart, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Request__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ;
  int arg3 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::Request *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Request" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Request" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if ( arg1 != Py_None ) { 
          result = (mvIMPACT::acquire::Request *)new SwigDirector_Request(arg1,arg2,arg3);  }  else {
          SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor");  SWIG_fail; } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Request, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Request__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; mvIMPACT::acquire::Request *arg2 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; mvIMPACT::acquire::Request *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__Request,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Request" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Request" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const &""'"); }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) { 
          result = (mvIMPACT::acquire::Request *)new SwigDirector_Request(arg1,(mvIMPACT::acquire::Request const &)*arg2);  }
         else {
          result = (mvIMPACT::acquire::Request *)new mvIMPACT::acquire::Request((mvIMPACT::acquire::Request const &)*arg2);  } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Request, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Request(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Request", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_Request__SWIG_1(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 3) { PyObject *retobj = _wrap_new_Request__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Request'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Request::Request(mvIMPACT::acquire::Device *,int)\n"
  "    mvIMPACT::acquire::Request::Request(PyObject *,mvIMPACT::acquire::Request const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_Request(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Request" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getComponentLocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::DeviceComponentLocator result; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getComponentLocator" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Request const *)arg1)->getComponentLocator(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::DeviceComponentLocator(static_cast< const mvIMPACT::acquire::DeviceComponentLocator& >(result))), SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getBufferPartCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getBufferPartCount" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Request const *)arg1)->getBufferPartCount(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getBufferPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::BufferPart *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "Request_getBufferPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getBufferPart" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Request_getBufferPart" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::BufferPart *) &((mvIMPACT::acquire::Request const *)arg1)->getBufferPart(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getName" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::string *) &((mvIMPACT::acquire::Request const *)arg1)->getName(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getNumber" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Request const *)arg1)->getNumber(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getImageBufferDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::ImageBufferDesc *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getImageBufferDesc" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageBufferDesc *) &((mvIMPACT::acquire::Request const *)arg1)->getImageBufferDesc();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getInfoIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::Component result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getInfoIterator" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Request const *)arg1)->getInfoIterator(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getImageProcessingResultsIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Component result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getImageProcessingResultsIterator" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Request const *)arg1)->getImageProcessingResultsIterator(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getHasProcessingBeenSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getHasProcessingBeenSkipped" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Request const *)arg1)->hasProcessingBeenSkipped(); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getChunkCounterCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getChunkCounterCount" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Request const *)arg1)->getChunkCounterCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getChunkCounterValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  SwigValueWrapper< mvIMPACT::acquire::EnumPropertyI64< long > > result;
  if (!SWIG_Python_UnpackTuple(args, "Request_getChunkCounterValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getChunkCounterValue" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Request_getChunkCounterValue" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Request const *)arg1)->getChunkCounterValue(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::PropertyI64(static_cast< const mvIMPACT::acquire::PropertyI64& >(result))), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getChunkTimerCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getChunkTimerCount" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Request const *)arg1)->getChunkTimerCount(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getChunkTimerValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  SwigValueWrapper< mvIMPACT::acquire::EnumPropertyF< double > > result;
  if (!SWIG_Python_UnpackTuple(args, "Request_getChunkTimerValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getChunkTimerValue" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Request_getChunkTimerValue" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Request const *)arg1)->getChunkTimerValue(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::PropertyF(static_cast< const mvIMPACT::acquire::PropertyF& >(result))), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getChunkGainCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getChunkGainCount" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::Request const *)arg1)->getChunkGainCount(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getChunkGain__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  SwigValueWrapper< mvIMPACT::acquire::EnumPropertyF< double > > result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getChunkGain" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Request_getChunkGain" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Request const *)arg1)->getChunkGain(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::PropertyF(static_cast< const mvIMPACT::acquire::PropertyF& >(result))), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_getChunkGain__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< mvIMPACT::acquire::EnumPropertyF< double > > result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getChunkGain" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Request_getChunkGain" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Request_getChunkGain" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::Request const *)arg1)->getChunkGain((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::PropertyF(static_cast< const mvIMPACT::acquire::PropertyF& >(result))), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_Request_getChunkGain(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "Request_getChunkGain", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_1;
    return _wrap_Request_getChunkGain__SWIG_0(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_Request_getChunkGain__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Request_getChunkGain'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Request::getChunkGain(unsigned int) const\n"
  "    mvIMPACT::acquire::Request::getChunkGain(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_Request_getIsOK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_getIsOK" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::Request const *)arg1)->isOK(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_configure" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->configure(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; std::string *arg2 = 0 ;
  mvIMPACT::acquire::TImageFileFormat arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ;
  int ecode3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_save" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Request_save" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Request_save" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Request_save" "', argument " "3"" of type '" "mvIMPACT::acquire::TImageFileFormat""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TImageFileFormat >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Request const *)arg1)->save((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_Request_save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_save" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Request_save" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Request_save" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Request const *)arg1)->save((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_Request_save(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "Request_save", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_Request_save__SWIG_1(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 3) { PyObject *retobj = _wrap_Request_save__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Request_save'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::Request::save(std::string const &,mvIMPACT::acquire::TImageFileFormat) const\n"
  "    mvIMPACT::acquire::Request::save(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_Request_unlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_unlock" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->unlock(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_attachUserBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *arg2 = (void *) 0 ; int arg3 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; int result;
  if (!SWIG_Python_UnpackTuple(args, "Request_attachUserBuffer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_attachUserBuffer" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); {  arg1->releasePythonUserBufferIfNeeded();
    if( !PyObject_CheckBuffer(swig_obj[1]) ) {
      PyErr_SetString( PyExc_ValueError, "Expected a mutable buffer object (e.g. bytearray)." ); SWIG_fail; } 
    Py_buffer* pythonUserBuffer = arg1->getPythonUserBuffer();
    int result = PyObject_GetBuffer( swig_obj[1], pythonUserBuffer, PyBUF_WRITABLE | PyBUF_C_CONTIGUOUS ); if( result == -1 ) {
      SWIG_fail; }  arg2 = pythonUserBuffer->buf; arg3 = pythonUserBuffer->len; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->attachUserBuffer(arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_detachUserBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_detachUserBuffer" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->detachUserBuffer(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_requestResult_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIRequestResult *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_requestResult_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIRequestResult *)& ((arg1)->requestResult); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_requestState_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIRequestState *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_requestState_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIRequestState *)& ((arg1)->requestState); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->infoFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoFrameNr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoFrameNr_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->infoFrameNr); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoExposeStart_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoExposeStart_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->infoExposeStart_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoExposeTime_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoExposeTime_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->infoExposeTime_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoTransferDelay_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoTransferDelay_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->infoTransferDelay_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoGain_dB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoGain_dB_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->infoGain_dB); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoTimeStamp_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoTimeStamp_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->infoTimeStamp_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoSettingUsed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoSettingUsed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->infoSettingUsed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoImageAverage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoImageAverage_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->infoImageAverage); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoVideoChannel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoVideoChannel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->infoVideoChannel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoCameraOutputUsed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraOutput *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoCameraOutputUsed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraOutput *)& ((arg1)->infoCameraOutputUsed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoLineCounter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoLineCounter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->infoLineCounter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoMissingData_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoMissingData_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->infoMissingData_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoIOStatesAtExposureStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoIOStatesAtExposureStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->infoIOStatesAtExposureStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_infoIOStatesAtExposureEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_infoIOStatesAtExposureEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->infoIOStatesAtExposureEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkPixelFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkPixelFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkPixelFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkDynamicRangeMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkDynamicRangeMin_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkDynamicRangeMin); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkDynamicRangeMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkDynamicRangeMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkDynamicRangeMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkExposureTime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkExposureTime_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkExposureTime); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkLineStatusAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkLineStatusAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkLineStatusAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkSequencerSetActive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkSequencerSetActive_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkSequencerSetActive); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_chunkmvCustomIdentifier_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_chunkmvCustomIdentifier_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkmvCustomIdentifier); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageMemoryMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIRequestImageMemoryMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageMemoryMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIRequestImageMemoryMode *)& ((arg1)->imageMemoryMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imagePixelFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIImageBufferPixelFormat *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imagePixelFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIImageBufferPixelFormat *)& ((arg1)->imagePixelFormat); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyPtr *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyPtr *)& ((arg1)->imageData); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageFooter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyPtr *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageFooter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyPtr *)& ((arg1)->imageFooter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageFooterSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageFooterSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageFooterSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imagePixelPitch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imagePixelPitch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imagePixelPitch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageChannelCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageChannelCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageChannelCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageChannelOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageChannelOffset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageChannelOffset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageChannelBitDepth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageChannelBitDepth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageChannelBitDepth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageLinePitch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageLinePitch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageLinePitch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageChannelDesc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageChannelDesc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->imageChannelDesc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageBytesPerPixel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageBytesPerPixel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageBytesPerPixel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageWidthTotal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageWidthTotal_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageWidthTotal); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageHeightTotal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageHeightTotal_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageHeightTotal); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_imageBayerMosaicParity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBayerMosaicParity *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Request_imageBayerMosaicParity_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBayerMosaicParity *)& ((arg1)->imageBayerMosaicParity); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_disown_Request(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Request *arg1 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Request" "', argument " "1"" of type '" "mvIMPACT::acquire::Request *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); if (director) director->swig_disown(); } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *Request_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__Request, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Request_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ImageRequestControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::ImageRequestControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageRequestControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ImageRequestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageRequestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageRequestControl *)new mvIMPACT::acquire::ImageRequestControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageRequestControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ImageRequestControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageRequestControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageRequestControl *)new mvIMPACT::acquire::ImageRequestControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageRequestControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ImageRequestControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_ImageRequestControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ImageRequestControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ImageRequestControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ImageRequestControl::ImageRequestControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::ImageRequestControl::ImageRequestControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_ImageRequestControl_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageRequestControl *arg1 = (mvIMPACT::acquire::ImageRequestControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIImageRequestControlMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageRequestControl_mode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageRequestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIImageRequestControlMode *)& ((arg1)->mode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageRequestControl_imageCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageRequestControl *arg1 = (mvIMPACT::acquire::ImageRequestControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageRequestControl_imageCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageRequestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageRequestControl_setting_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageRequestControl *arg1 = (mvIMPACT::acquire::ImageRequestControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageRequestControl_setting_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageRequestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->setting); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageRequestControl_requestQueue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageRequestControl *arg1 = (mvIMPACT::acquire::ImageRequestControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageRequestControl_requestQueue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageRequestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->requestQueue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageRequestControl_resultQueue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageRequestControl *arg1 = (mvIMPACT::acquire::ImageRequestControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageRequestControl_resultQueue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageRequestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->resultQueue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageRequestControl_requestToUse_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageRequestControl *arg1 = (mvIMPACT::acquire::ImageRequestControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageRequestControl_requestToUse_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageRequestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->requestToUse); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ImageRequestControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageRequestControl *arg1 = (mvIMPACT::acquire::ImageRequestControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageRequestControl" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageRequestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ImageRequestControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImageRequestControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_RequestFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestFactory *arg1 = (mvIMPACT::acquire::RequestFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RequestFactory" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestFactory *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestFactory * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestFactory_createRequest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RequestFactory *arg1 = (mvIMPACT::acquire::RequestFactory *) 0 ;
  mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; PyObject *swig_obj[3] ; Swig::Director *director = 0;
  bool upcall = false; mvIMPACT::acquire::Request *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "RequestFactory_createRequest", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestFactory, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestFactory_createRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestFactory *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RequestFactory_createRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RequestFactory_createRequest" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (mvIMPACT::acquire::Request *)(arg1)->mvIMPACT::acquire::RequestFactory::createRequest(arg2,arg3); }  else {
          result = (mvIMPACT::acquire::Request *)(arg1)->createRequest(arg2,arg3); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  director = SWIG_DIRECTOR_CAST(result); if (director) { resultobj = director->swig_get_self();
    Py_INCREF(resultobj); }  else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); }  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result))); }  return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_new_RequestFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::RequestFactory *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args; arg1 = swig_obj[0]; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {  result = (mvIMPACT::acquire::RequestFactory *)new SwigDirector_RequestFactory(arg1);  }
         else { result = (mvIMPACT::acquire::RequestFactory *)new mvIMPACT::acquire::RequestFactory();  } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__RequestFactory, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_disown_RequestFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestFactory *arg1 = (mvIMPACT::acquire::RequestFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestFactory, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_RequestFactory" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestFactory *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestFactory * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); if (director) director->swig_disown(); } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *RequestFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__RequestFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RequestFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FunctionInterface__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ;
  mvIMPACT::acquire::RequestFactory *arg2 = (mvIMPACT::acquire::RequestFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; mvIMPACT::acquire::FunctionInterface *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FunctionInterface" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__RequestFactory, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FunctionInterface" "', argument " "2"" of type '" "mvIMPACT::acquire::RequestFactory *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::RequestFactory * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::FunctionInterface *)new mvIMPACT::acquire::FunctionInterface(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FunctionInterface__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::FunctionInterface *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FunctionInterface" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::FunctionInterface *)new mvIMPACT::acquire::FunctionInterface(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FunctionInterface__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::FunctionInterface *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FunctionInterface" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FunctionInterface" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::FunctionInterface *)new mvIMPACT::acquire::FunctionInterface((mvIMPACT::acquire::FunctionInterface const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FunctionInterface(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FunctionInterface", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    int _v = 0; { void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Device, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; return _wrap_new_FunctionInterface__SWIG_1(self, argc, argv);} 
  check_1: if (argc == 1) { PyObject *retobj = _wrap_new_FunctionInterface__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_FunctionInterface__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FunctionInterface'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::FunctionInterface(mvIMPACT::acquire::Device *,mvIMPACT::acquire::RequestFactory *)\n"
  "    mvIMPACT::acquire::FunctionInterface::FunctionInterface(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::FunctionInterface::FunctionInterface(mvIMPACT::acquire::FunctionInterface const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_FunctionInterface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FunctionInterface" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_acquisitionStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_acquisitionStart" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->acquisitionStart(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_acquisitionStop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_acquisitionStop" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->acquisitionStop(); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createImageRequestControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; std::string *arg3 = 0 ;
  mvIMPACT::acquire::ComponentList *arg4 = (mvIMPACT::acquire::ComponentList *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ; int res3 = SWIG_OLDOBJ ; void *argp4 = 0 ; int res4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_createImageRequestControl" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_createImageRequestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createImageRequestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionInterface_createImageRequestControl" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createImageRequestControl" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mvIMPACT__acquire__ComponentList, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FunctionInterface_createImageRequestControl" "', argument " "4"" of type '" "mvIMPACT::acquire::ComponentList *""'");  }
   arg4 = reinterpret_cast< mvIMPACT::acquire::ComponentList * >(argp4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->createImageRequestControl((std::string const &)*arg2,(std::string const &)*arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createImageRequestControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_createImageRequestControl" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_createImageRequestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createImageRequestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionInterface_createImageRequestControl" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createImageRequestControl" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->createImageRequestControl((std::string const &)*arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createImageRequestControl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_createImageRequestControl" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_createImageRequestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createImageRequestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->createImageRequestControl((std::string const &)*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createImageRequestControl(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_createImageRequestControl", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_FunctionInterface_createImageRequestControl__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_FunctionInterface_createImageRequestControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_FunctionInterface_createImageRequestControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_createImageRequestControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::createImageRequestControl(std::string const &,std::string const &,mvIMPACT::acquire::ComponentList *)\n"
  "    mvIMPACT::acquire::FunctionInterface::createImageRequestControl(std::string const &,std::string const &)\n"
  "    mvIMPACT::acquire::FunctionInterface::createImageRequestControl(std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createSetting__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; std::string *arg3 = 0 ;
  mvIMPACT::acquire::ComponentList *arg4 = (mvIMPACT::acquire::ComponentList *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ; int res3 = SWIG_OLDOBJ ; void *argp4 = 0 ; int res4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_createSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_createSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionInterface_createSetting" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createSetting" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mvIMPACT__acquire__ComponentList, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FunctionInterface_createSetting" "', argument " "4"" of type '" "mvIMPACT::acquire::ComponentList *""'");  }
   arg4 = reinterpret_cast< mvIMPACT::acquire::ComponentList * >(argp4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->createSetting((std::string const &)*arg2,(std::string const &)*arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createSetting__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_createSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_createSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionInterface_createSetting" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createSetting" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->createSetting((std::string const &)*arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createSetting__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_createSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_createSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_createSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (int)(arg1)->createSetting((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createSetting(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_createSetting", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_FunctionInterface_createSetting__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_FunctionInterface_createSetting__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_FunctionInterface_createSetting__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_createSetting'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::createSetting(std::string const &,std::string const &,mvIMPACT::acquire::ComponentList *)\n"
  "    mvIMPACT::acquire::FunctionInterface::createSetting(std::string const &,std::string const &)\n"
  "    mvIMPACT::acquire::FunctionInterface::createSetting(std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_deleteSettingFromStack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_deleteSettingFromStack" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->deleteSettingFromStack(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_deleteSetting__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; mvIMPACT::acquire::TStorageLocation arg3 ; mvIMPACT::acquire::TScope arg4 ; void *argp1 = 0 ;
  int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_deleteSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_deleteSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_deleteSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_deleteSetting" "', argument " "3"" of type '" "mvIMPACT::acquire::TStorageLocation""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TStorageLocation >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FunctionInterface_deleteSetting" "', argument " "4"" of type '" "mvIMPACT::acquire::TScope""'"); }
    arg4 = static_cast< mvIMPACT::acquire::TScope >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->deleteSetting((std::string const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_deleteSetting__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; mvIMPACT::acquire::TStorageLocation arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int val3 ; int ecode3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_deleteSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_deleteSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_deleteSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_deleteSetting" "', argument " "3"" of type '" "mvIMPACT::acquire::TStorageLocation""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TStorageLocation >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->deleteSetting((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_deleteSetting__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_deleteSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_deleteSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_deleteSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->deleteSetting((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_deleteSetting(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_deleteSetting", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_FunctionInterface_deleteSetting__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_FunctionInterface_deleteSetting__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_FunctionInterface_deleteSetting__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_deleteSetting'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::deleteSetting(std::string const &,mvIMPACT::acquire::TStorageLocation,mvIMPACT::acquire::TScope) const\n"
  "    mvIMPACT::acquire::FunctionInterface::deleteSetting(std::string const &,mvIMPACT::acquire::TStorageLocation) const\n"
  "    mvIMPACT::acquire::FunctionInterface::deleteSetting(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getAvailableSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_getAvailableSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::vector< std::string,std::allocator< std::string > > *) &((mvIMPACT::acquire::FunctionInterface const *)arg1)->getAvailableSettings();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  { const unsigned int len = result->size();
    resultobj = PyTuple_New(len); if (resultobj) { for (unsigned int i = 0; i < len; i++) {
        PyTuple_SET_ITEM(resultobj, i, CToPyObject<std::string>(result->at(i))); }  }  else {
      Py_INCREF(Py_None); resultobj = Py_None; }  }  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getAvailableImageRequestControls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_getAvailableImageRequestControls" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::vector< std::string,std::allocator< std::string > > *) &((mvIMPACT::acquire::FunctionInterface const *)arg1)->getAvailableImageRequestControls();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  { const unsigned int len = result->size();
    resultobj = PyTuple_New(len); if (resultobj) { for (unsigned int i = 0; i < len; i++) {
        PyTuple_SET_ITEM(resultobj, i, CToPyObject<std::string>(result->at(i))); }  }  else {
      Py_INCREF(Py_None); resultobj = Py_None; }  }  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getRequest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; Swig::Director *director = 0;
  mvIMPACT::acquire::Request *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "FunctionInterface_getRequest", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_getRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_getRequest" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Request *)((mvIMPACT::acquire::FunctionInterface const *)arg1)->getRequest(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  director = SWIG_DIRECTOR_CAST(result);
  if (director) { resultobj = director->swig_get_self(); Py_INCREF(resultobj); }  else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); } 
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getSetting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::ComponentList result;
  if (!SWIG_Python_UnpackTuple(args, "FunctionInterface_getSetting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_getSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_getSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_getSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::FunctionInterface const *)arg1)->getSetting((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::ComponentList(static_cast< const mvIMPACT::acquire::ComponentList& >(result))), SWIGTYPE_p_mvIMPACT__acquire__ComponentList, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestConfigure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; PyObject *swig_obj[2] ; int result;
  if (!SWIG_Python_UnpackTuple(args, "FunctionInterface_imageRequestConfigure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_imageRequestConfigure" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_imageRequestConfigure" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestConfigure((mvIMPACT::acquire::Request const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestResultQueueElementCount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_imageRequestResultQueueElementCount" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_imageRequestResultQueueElementCount" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestResultQueueElementCount(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestResultQueueElementCount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_imageRequestResultQueueElementCount" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestResultQueueElementCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestResultQueueElementCount(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_imageRequestResultQueueElementCount", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_FunctionInterface_imageRequestResultQueueElementCount__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_FunctionInterface_imageRequestResultQueueElementCount__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_imageRequestResultQueueElementCount'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount(int) const\n"
  "    mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestReset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ; int arg2 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; PyObject *swig_obj[3] ;
  int result; if (!SWIG_Python_UnpackTuple(args, "FunctionInterface_imageRequestReset", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_imageRequestReset" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_imageRequestReset" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_imageRequestReset" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestReset(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestUnlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; int result;
  if (!SWIG_Python_UnpackTuple(args, "FunctionInterface_imageRequestUnlock", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_imageRequestUnlock" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_imageRequestUnlock" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestUnlock(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestWaitFor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ; int arg2 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; int result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_imageRequestWaitFor" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_imageRequestWaitFor" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_imageRequestWaitFor" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestWaitFor(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestWaitFor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_imageRequestWaitFor" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_imageRequestWaitFor" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestWaitFor(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestWaitFor(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_imageRequestWaitFor", 0, 3, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_FunctionInterface_imageRequestWaitFor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_FunctionInterface_imageRequestWaitFor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_imageRequestWaitFor'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor(int,int) const\n"
  "    mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor(int) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getCurrentCaptureBufferLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::ImageRequestControl *arg2 = 0 ; int *arg3 = 0 ; int *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; int temp3 ; int res3 = SWIG_TMPOBJ ; int temp4 ; int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ; int result; arg3 = &temp3; arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "FunctionInterface_getCurrentCaptureBufferLayout", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageRequestControl &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageRequestControl &""'"); }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->getCurrentCaptureBufferLayout(*arg2,*arg3,*arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); }  else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); } 
  if (SWIG_IsTmpObj(res4)) { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); }  else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags)); } 
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_isRequestNrValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "FunctionInterface_isRequestNrValid", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_isRequestNrValid" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_isRequestNrValid" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::FunctionInterface const *)arg1)->isRequestNrValid(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_isSettingAvailable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; mvIMPACT::acquire::TStorageLocation arg3 ; mvIMPACT::acquire::TScope arg4 ; void *argp1 = 0 ;
  int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_isSettingAvailable" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_isSettingAvailable" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_isSettingAvailable" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_isSettingAvailable" "', argument " "3"" of type '" "mvIMPACT::acquire::TStorageLocation""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TStorageLocation >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FunctionInterface_isSettingAvailable" "', argument " "4"" of type '" "mvIMPACT::acquire::TScope""'"); }
    arg4 = static_cast< mvIMPACT::acquire::TScope >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->isSettingAvailable((std::string const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_isSettingAvailable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; mvIMPACT::acquire::TStorageLocation arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int val3 ; int ecode3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_isSettingAvailable" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_isSettingAvailable" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_isSettingAvailable" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_isSettingAvailable" "', argument " "3"" of type '" "mvIMPACT::acquire::TStorageLocation""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TStorageLocation >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->isSettingAvailable((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_isSettingAvailable__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_isSettingAvailable" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_isSettingAvailable" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_isSettingAvailable" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->isSettingAvailable((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_isSettingAvailable(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_isSettingAvailable", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_FunctionInterface_isSettingAvailable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_FunctionInterface_isSettingAvailable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_FunctionInterface_isSettingAvailable__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_isSettingAvailable'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::isSettingAvailable(std::string const &,mvIMPACT::acquire::TStorageLocation,mvIMPACT::acquire::TScope) const\n"
  "    mvIMPACT::acquire::FunctionInterface::isSettingAvailable(std::string const &,mvIMPACT::acquire::TStorageLocation) const\n"
  "    mvIMPACT::acquire::FunctionInterface::isSettingAvailable(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSetting__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; mvIMPACT::acquire::TStorageFlag arg3 ; mvIMPACT::acquire::TScope arg4 ; void *argp1 = 0 ;
  int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_loadSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_loadSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_loadSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_loadSetting" "', argument " "3"" of type '" "mvIMPACT::acquire::TStorageFlag""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TStorageFlag >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FunctionInterface_loadSetting" "', argument " "4"" of type '" "mvIMPACT::acquire::TScope""'"); }
    arg4 = static_cast< mvIMPACT::acquire::TScope >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSetting((std::string const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSetting__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; mvIMPACT::acquire::TStorageFlag arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int val3 ; int ecode3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_loadSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_loadSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_loadSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_loadSetting" "', argument " "3"" of type '" "mvIMPACT::acquire::TStorageFlag""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TStorageFlag >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSetting((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSetting__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_loadSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_loadSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_loadSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSetting((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSetting(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_loadSetting", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_FunctionInterface_loadSetting__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_FunctionInterface_loadSetting__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_FunctionInterface_loadSetting__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_loadSetting'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::loadSetting(std::string const &,mvIMPACT::acquire::TStorageFlag,mvIMPACT::acquire::TScope) const\n"
  "    mvIMPACT::acquire::FunctionInterface::loadSetting(std::string const &,mvIMPACT::acquire::TStorageFlag) const\n"
  "    mvIMPACT::acquire::FunctionInterface::loadSetting(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSettingFromStack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_loadSettingFromStack" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->loadSettingFromStack(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadAndDeleteSettingFromStack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_loadAndDeleteSettingFromStack" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->loadAndDeleteSettingFromStack(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSettingFromDefault__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::TScope arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_loadSettingFromDefault" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_loadSettingFromDefault" "', argument " "2"" of type '" "mvIMPACT::acquire::TScope""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScope >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSettingFromDefault(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSettingFromDefault__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_loadSettingFromDefault" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSettingFromDefault();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSettingFromDefault(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_loadSettingFromDefault", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_FunctionInterface_loadSettingFromDefault__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_FunctionInterface_loadSettingFromDefault__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_loadSettingFromDefault'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::loadSettingFromDefault(mvIMPACT::acquire::TScope) const\n"
  "    mvIMPACT::acquire::FunctionInterface::loadSettingFromDefault() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_requestCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_requestCount" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->requestCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveCurrentSettingOnStack__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::TStorageFlag arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_saveCurrentSettingOnStack" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_saveCurrentSettingOnStack" "', argument " "2"" of type '" "mvIMPACT::acquire::TStorageFlag""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TStorageFlag >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->saveCurrentSettingOnStack(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveCurrentSettingOnStack__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_saveCurrentSettingOnStack" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->saveCurrentSettingOnStack(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveCurrentSettingOnStack(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_saveCurrentSettingOnStack", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_FunctionInterface_saveCurrentSettingOnStack__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_FunctionInterface_saveCurrentSettingOnStack__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_saveCurrentSettingOnStack'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack(mvIMPACT::acquire::TStorageFlag)\n"
  "    mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack()\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSetting__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; mvIMPACT::acquire::TStorageFlag arg3 ; mvIMPACT::acquire::TScope arg4 ; void *argp1 = 0 ;
  int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_saveSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_saveSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_saveSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_saveSetting" "', argument " "3"" of type '" "mvIMPACT::acquire::TStorageFlag""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TStorageFlag >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FunctionInterface_saveSetting" "', argument " "4"" of type '" "mvIMPACT::acquire::TScope""'"); }
    arg4 = static_cast< mvIMPACT::acquire::TScope >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSetting((std::string const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSetting__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; mvIMPACT::acquire::TStorageFlag arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int val3 ; int ecode3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_saveSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_saveSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_saveSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FunctionInterface_saveSetting" "', argument " "3"" of type '" "mvIMPACT::acquire::TStorageFlag""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TStorageFlag >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSetting((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSetting__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_saveSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_saveSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_saveSetting" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSetting((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSetting(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_saveSetting", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_FunctionInterface_saveSetting__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_FunctionInterface_saveSetting__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_FunctionInterface_saveSetting__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_saveSetting'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::saveSetting(std::string const &,mvIMPACT::acquire::TStorageFlag,mvIMPACT::acquire::TScope) const\n"
  "    mvIMPACT::acquire::FunctionInterface::saveSetting(std::string const &,mvIMPACT::acquire::TStorageFlag) const\n"
  "    mvIMPACT::acquire::FunctionInterface::saveSetting(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSettingToDefault__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::TScope arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_saveSettingToDefault" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionInterface_saveSettingToDefault" "', argument " "2"" of type '" "mvIMPACT::acquire::TScope""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScope >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSettingToDefault(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSettingToDefault__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_saveSettingToDefault" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSettingToDefault();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSettingToDefault(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_saveSettingToDefault", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_FunctionInterface_saveSettingToDefault__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_FunctionInterface_saveSettingToDefault__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_saveSettingToDefault'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface::saveSettingToDefault(mvIMPACT::acquire::TScope) const\n"
  "    mvIMPACT::acquire::FunctionInterface::saveSettingToDefault() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestSingle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_imageRequestSingle" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)mvIMPACT_acquire_FunctionInterface_imageRequestSingle__SWIG_0((mvIMPACT::acquire::FunctionInterface const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestSingle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::ImageRequestControl *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionInterface_imageRequestSingle" "', argument " "1"" of type '" "mvIMPACT::acquire::FunctionInterface const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FunctionInterface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_imageRequestSingle" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageRequestControl &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_imageRequestSingle" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageRequestControl &""'"); }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)mvIMPACT_acquire_FunctionInterface_imageRequestSingle__SWIG_1((mvIMPACT::acquire::FunctionInterface const *)arg1,*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestSingle(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionInterface_imageRequestSingle", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_FunctionInterface_imageRequestSingle__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_FunctionInterface_imageRequestSingle__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionInterface_imageRequestSingle'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::FunctionInterface::imageRequestSingle(void) const\n"
  "    mvIMPACT::acquire::FunctionInterface::imageRequestSingle(mvIMPACT::acquire::ImageRequestControl &) const\n"); return 0; }
SWIGINTERN PyObject *FunctionInterface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FunctionInterface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::Info *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Info" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Info *)new mvIMPACT::acquire::Info(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Info, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_deviceDriverVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_deviceDriverVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceDriverVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_driverDate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_driverDate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->driverDate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_driverVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_driverVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->driverVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIDeviceState *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_state_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceState *)& ((arg1)->state); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_loadedSettings_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_loadedSettings_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->loadedSettings); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_logFile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_logFile_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->logFile); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_systemPhysicalProcessorCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_systemPhysicalProcessorCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->systemPhysicalProcessorCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_systemLogicalProcessorCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_systemLogicalProcessorCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->systemLogicalProcessorCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_captureBufferAlignment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_captureBufferAlignment_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->captureBufferAlignment); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Info_recommendedListsForUIs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_recommendedListsForUIs_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->recommendedListsForUIs); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_Info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Info *arg1 = (mvIMPACT::acquire::Info *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Info" "', argument " "1"" of type '" "mvIMPACT::acquire::Info *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Info * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *Info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__Info, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Info_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BasicDeviceSettings__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::BasicDeviceSettings *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BasicDeviceSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BasicDeviceSettings" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BasicDeviceSettings" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::BasicDeviceSettings *)new mvIMPACT::acquire::BasicDeviceSettings(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettings, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_BasicDeviceSettings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::BasicDeviceSettings *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BasicDeviceSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::BasicDeviceSettings *)new mvIMPACT::acquire::BasicDeviceSettings(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettings, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_BasicDeviceSettings(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BasicDeviceSettings", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_BasicDeviceSettings__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_BasicDeviceSettings__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BasicDeviceSettings'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::BasicDeviceSettings::BasicDeviceSettings(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::BasicDeviceSettings::BasicDeviceSettings(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_BasicDeviceSettings_basedOn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::BasicDeviceSettings *arg1 = (mvIMPACT::acquire::BasicDeviceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicDeviceSettings_basedOn_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BasicDeviceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BasicDeviceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->basedOn); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_BasicDeviceSettings_imageRequestTimeout_ms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::BasicDeviceSettings *arg1 = (mvIMPACT::acquire::BasicDeviceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicDeviceSettings_imageRequestTimeout_ms_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BasicDeviceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BasicDeviceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageRequestTimeout_ms); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_BasicDeviceSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::BasicDeviceSettings *arg1 = (mvIMPACT::acquire::BasicDeviceSettings *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BasicDeviceSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::BasicDeviceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BasicDeviceSettings * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *BasicDeviceSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BasicDeviceSettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_TriggerControl_getDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriggerControl_getDescription" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::TriggerControl const *)arg1)->getDescription(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TriggerControl_triggerSoftware(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriggerControl_triggerSoftware" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::TriggerControl const *)arg1)->triggerSoftware(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TriggerControl_triggerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriggerControl_triggerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TriggerControl_triggerSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriggerControl_triggerSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TriggerControl_triggerActivation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriggerControl_triggerActivation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerActivation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TriggerControl_triggerDivider_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriggerControl_triggerDivider_get" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->triggerDivider); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TriggerControl_triggerDelayAbs_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriggerControl_triggerDelayAbs_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->triggerDelayAbs_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TriggerControl_triggerDelayLines_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriggerControl_triggerDelayLines_get" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->triggerDelayLines); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TriggerControl_triggerOverlap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64DeviceTriggerOverlap *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriggerControl_triggerOverlap_get" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64DeviceTriggerOverlap *)& ((arg1)->triggerOverlap); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_TriggerControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::TriggerControl *arg1 = (mvIMPACT::acquire::TriggerControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::TriggerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::TriggerControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *TriggerControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ImageDestination__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::ImageDestination *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageDestination" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ImageDestination" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageDestination" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageDestination *)new mvIMPACT::acquire::ImageDestination(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageDestination__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ImageDestination *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageDestination" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageDestination *)new mvIMPACT::acquire::ImageDestination(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageDestination(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ImageDestination", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_ImageDestination__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ImageDestination__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ImageDestination'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ImageDestination::ImageDestination(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::ImageDestination::ImageDestination(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_ImageDestination_pixelFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIImageDestinationPixelFormat *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_pixelFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIImageDestinationPixelFormat *)& ((arg1)->pixelFormat); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageDestination_scalerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIScalerMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_scalerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIScalerMode *)& ((arg1)->scalerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageDestination_scalerInterpolationMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIScalerInterpolationMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_scalerInterpolationMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIScalerInterpolationMode *)& ((arg1)->scalerInterpolationMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageDestination_scalerAoiEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_scalerAoiEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->scalerAoiEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageDestination_scalerAoiHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_scalerAoiHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->scalerAoiHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageDestination_scalerAoiStartX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_scalerAoiStartX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->scalerAoiStartX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageDestination_scalerAoiStartY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_scalerAoiStartY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->scalerAoiStartY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageDestination_scalerAoiWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_scalerAoiWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->scalerAoiWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageDestination_imageWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_imageWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageDestination_imageHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageDestination_imageHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ImageDestination(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageDestination *arg1 = (mvIMPACT::acquire::ImageDestination *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageDestination" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageDestination *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageDestination * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ImageDestination_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImageDestination_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RequestInfoConfiguration__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::RequestInfoConfiguration *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RequestInfoConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RequestInfoConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RequestInfoConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::RequestInfoConfiguration *)new mvIMPACT::acquire::RequestInfoConfiguration(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_RequestInfoConfiguration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::RequestInfoConfiguration *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RequestInfoConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::RequestInfoConfiguration *)new mvIMPACT::acquire::RequestInfoConfiguration(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_RequestInfoConfiguration(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_RequestInfoConfiguration", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_new_RequestInfoConfiguration__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_RequestInfoConfiguration__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RequestInfoConfiguration'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::RequestInfoConfiguration::RequestInfoConfiguration(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::RequestInfoConfiguration::RequestInfoConfiguration(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_frameNr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_frameNr_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->frameNr); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_timeStamp_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_timeStamp_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->timeStamp_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_settingUsed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_settingUsed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->settingUsed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_frameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_frameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->frameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_exposeStart_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_exposeStart_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->exposeStart_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_exposeTime_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_exposeTime_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->exposeTime_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_gain_dB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_gain_dB_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gain_dB); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_videoChannel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_videoChannel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->videoChannel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_missingData_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_missingData_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->missingData_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_transferDelay_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_transferDelay_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->transferDelay_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_imageAverage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_imageAverage_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->imageAverage); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_IOStatesAtExposureStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_IOStatesAtExposureStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->IOStatesAtExposureStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_triggerCounterAcquisitionStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_triggerCounterAcquisitionStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->triggerCounterAcquisitionStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_triggerCounterFrameStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_triggerCounterFrameStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->triggerCounterFrameStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_lineCounter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_lineCounter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->lineCounter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_userData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_userData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->userData); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RequestInfoConfiguration_lineStatusAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestInfoConfiguration_lineStatusAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->lineStatusAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_RequestInfoConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestInfoConfiguration *arg1 = (mvIMPACT::acquire::RequestInfoConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RequestInfoConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::RequestInfoConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RequestInfoConfiguration * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *RequestInfoConfiguration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RequestInfoConfiguration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_WBAoiMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAoiMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_WBAoiMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAoiMode *)& ((arg1)->WBAoiMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_aoiHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_aoiHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_aoiStartX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_aoiStartX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiStartX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_aoiStartY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_aoiStartY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiStartY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_aoiWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_aoiWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_totalGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_totalGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->totalGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_redGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_redGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->redGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_greenGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_greenGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->greenGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_blueGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_blueGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->blueGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_WhiteBalanceSettings_WBResult_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBayerWhiteBalanceResult *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalanceSettings_WBResult_get" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBayerWhiteBalanceResult *)& ((arg1)->WBResult); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_WhiteBalanceSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::WhiteBalanceSettings *arg1 = (mvIMPACT::acquire::WhiteBalanceSettings *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WhiteBalanceSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalanceSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalanceSettings * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *WhiteBalanceSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_GainOffsetKneeChannelParameters_gain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GainOffsetKneeChannelParameters *arg1 = (mvIMPACT::acquire::GainOffsetKneeChannelParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GainOffsetKneeChannelParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GainOffsetKneeChannelParameters_gain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GainOffsetKneeChannelParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GainOffsetKneeChannelParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_GainOffsetKneeChannelParameters_offset_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GainOffsetKneeChannelParameters *arg1 = (mvIMPACT::acquire::GainOffsetKneeChannelParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GainOffsetKneeChannelParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GainOffsetKneeChannelParameters_offset_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GainOffsetKneeChannelParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GainOffsetKneeChannelParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->offset_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_GainOffsetKneeChannelParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GainOffsetKneeChannelParameters *arg1 = (mvIMPACT::acquire::GainOffsetKneeChannelParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GainOffsetKneeChannelParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GainOffsetKneeChannelParameters" "', argument " "1"" of type '" "mvIMPACT::acquire::GainOffsetKneeChannelParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GainOffsetKneeChannelParameters * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *GainOffsetKneeChannelParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GainOffsetKneeChannelParameters, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_LUTParameters_gamma_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTParameters_gamma_get" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gamma); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTParameters_gammaAlpha_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTParameters_gammaAlpha_get" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gammaAlpha); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTParameters_gammaMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyILUTGammaMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTParameters_gammaMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyILUTGammaMode *)& ((arg1)->gammaMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTParameters_gammaStartThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTParameters_gammaStartThreshold_get" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->gammaStartThreshold); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTParameters_gammaInverter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTParameters_gammaInverter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gammaInverter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTParameters_valueCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTParameters_valueCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->valueCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTParameters_inputValues_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTParameters_inputValues_get" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->inputValues); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTParameters_outputValues_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTParameters_outputValues_get" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->outputValues); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTParameters_directValues_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTParameters_directValues_get" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->directValues); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_LUTParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::LUTParameters *arg1 = (mvIMPACT::acquire::LUTParameters *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LUTParameters" "', argument " "1"" of type '" "mvIMPACT::acquire::LUTParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::LUTParameters * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *LUTParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_MirrorParameters_mirrorMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MirrorParameters *arg1 = (mvIMPACT::acquire::MirrorParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIMirrorMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MirrorParameters, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MirrorParameters_mirrorMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MirrorParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MirrorParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIMirrorMode *)& ((arg1)->mirrorMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_MirrorParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::MirrorParameters *arg1 = (mvIMPACT::acquire::MirrorParameters *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MirrorParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MirrorParameters" "', argument " "1"" of type '" "mvIMPACT::acquire::MirrorParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MirrorParameters * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *MirrorParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__MirrorParameters, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ImageProcessing__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::ImageProcessing *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageProcessing" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ImageProcessing" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageProcessing" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageProcessing *)new mvIMPACT::acquire::ImageProcessing(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageProcessing__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ImageProcessing *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageProcessing" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageProcessing *)new mvIMPACT::acquire::ImageProcessing(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageProcessing__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ImageProcessing *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageProcessing" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageProcessing" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageProcessing *)new mvIMPACT::acquire::ImageProcessing((mvIMPACT::acquire::ImageProcessing const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageProcessing(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ImageProcessing", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    int _v = 0; { void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Device, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; return _wrap_new_ImageProcessing__SWIG_1(self, argc, argv);}  check_1:
  if (argc == 1) { PyObject *retobj = _wrap_new_ImageProcessing__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ImageProcessing__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ImageProcessing'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ImageProcessing::ImageProcessing(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::ImageProcessing::ImageProcessing(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::ImageProcessing::ImageProcessing(mvIMPACT::acquire::ImageProcessing const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_ImageProcessing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageProcessing" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorProcessing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIColorProcessingMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorProcessing_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIColorProcessingMode *)& ((arg1)->colorProcessing); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_bayerConversionMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBayerConversionMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_bayerConversionMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBayerConversionMode *)& ((arg1)->bayerConversionMode); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_adaptiveEdgeSensingPlusSharpenThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_adaptiveEdgeSensingPlusSharpenThreshold_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->adaptiveEdgeSensingPlusSharpenThreshold); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_adaptiveEdgeSensingPlusSharpenGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_adaptiveEdgeSensingPlusSharpenGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->adaptiveEdgeSensingPlusSharpenGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_whiteBalance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIWhiteBalanceParameter *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_whiteBalance_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIWhiteBalanceParameter *)& ((arg1)->whiteBalance); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_whiteBalanceCalibration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIWhiteBalanceCalibrationMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_whiteBalanceCalibration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIWhiteBalanceCalibrationMode *)& ((arg1)->whiteBalanceCalibration);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_filter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIImageProcessingFilter *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_filter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIImageProcessingFilter *)& ((arg1)->filter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_mirrorOperationMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIMirrorOperationMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_mirrorOperationMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIMirrorOperationMode *)& ((arg1)->mirrorOperationMode); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_mirrorModeGlobal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIMirrorMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_mirrorModeGlobal_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIMirrorMode *)& ((arg1)->mirrorModeGlobal); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_polarizedDataExtractionEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_polarizedDataExtractionEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->polarizedDataExtractionEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_polarizedDataExtractionMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIPolarizedDataExtractionMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_polarizedDataExtractionMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIPolarizedDataExtractionMode *)& ((arg1)->polarizedDataExtractionMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_polarizedDataExtractionInterpolationMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIPolarizedDataExtractionInterpolationMode *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_polarizedDataExtractionInterpolationMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIPolarizedDataExtractionInterpolationMode *)& ((arg1)->polarizedDataExtractionInterpolationMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_polarizedDataExtractionChannelIndex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_polarizedDataExtractionChannelIndex_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->polarizedDataExtractionChannelIndex); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_polarizedDataExtractionLowerLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_polarizedDataExtractionLowerLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->polarizedDataExtractionLowerLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_polarizedDataExtractionUpperLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_polarizedDataExtractionUpperLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->polarizedDataExtractionUpperLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_defectivePixelsFilterMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDefectivePixelsFilterMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_defectivePixelsFilterMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDefectivePixelsFilterMode *)& ((arg1)->defectivePixelsFilterMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_defectivePixelsFilterLeakyPixelDeviation_ADCLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_defectivePixelsFilterLeakyPixelDeviation_ADCLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->defectivePixelsFilterLeakyPixelDeviation_ADCLimit);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_defectivePixelsFilterColdPixelDeviation_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_defectivePixelsFilterColdPixelDeviation_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->defectivePixelsFilterColdPixelDeviation_pc);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_defectivePixelsMaxDetectionCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_defectivePixelsMaxDetectionCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->defectivePixelsMaxDetectionCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_defectivePixelsFound_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_defectivePixelsFound_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->defectivePixelsFound); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_defectivePixelOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_defectivePixelOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->defectivePixelOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_defectivePixelOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_defectivePixelOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->defectivePixelOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_defectivePixelReadFromDevice_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_defectivePixelReadFromDevice_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->defectivePixelReadFromDevice); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_defectivePixelWriteToDevice_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_defectivePixelWriteToDevice_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->defectivePixelWriteToDevice); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIFlatFieldFilterMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIFlatFieldFilterMode *)& ((arg1)->flatFieldFilterMode); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCorrectionMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIFlatFieldFilterCorrectionMode *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCorrectionMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIFlatFieldFilterCorrectionMode *)& ((arg1)->flatFieldFilterCorrectionMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCorrectionModeReverseX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCorrectionModeReverseX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->flatFieldFilterCorrectionModeReverseX);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCorrectionModeReverseY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCorrectionModeReverseY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->flatFieldFilterCorrectionModeReverseY);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCorrectionAoiMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAoiMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCorrectionAoiMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAoiMode *)& ((arg1)->flatFieldFilterCorrectionAoiMode); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCorrectionAoiOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCorrectionAoiOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flatFieldFilterCorrectionAoiOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCorrectionAoiOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCorrectionAoiOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flatFieldFilterCorrectionAoiOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCorrectionAoiWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCorrectionAoiWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flatFieldFilterCorrectionAoiWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCorrectionAoiHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCorrectionAoiHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flatFieldFilterCorrectionAoiHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCalibrationImageCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCalibrationImageCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flatFieldFilterCalibrationImageCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCalibrationAoiMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAoiMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCalibrationAoiMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAoiMode *)& ((arg1)->flatFieldFilterCalibrationAoiMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCalibrationAoiOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCalibrationAoiOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flatFieldFilterCalibrationAoiOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCalibrationAoiOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCalibrationAoiOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flatFieldFilterCalibrationAoiOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCalibrationAoiWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCalibrationAoiWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flatFieldFilterCalibrationAoiWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_flatFieldFilterCalibrationAoiHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_flatFieldFilterCalibrationAoiHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flatFieldFilterCalibrationAoiHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_darkCurrentFilterMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDarkCurrentFilterMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_darkCurrentFilterMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDarkCurrentFilterMode *)& ((arg1)->darkCurrentFilterMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_darkCurrentFilterCalibrationImageCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_darkCurrentFilterCalibrationImageCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->darkCurrentFilterCalibrationImageCount); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_gainOffsetKneeEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_gainOffsetKneeEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gainOffsetKneeEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_gainOffsetKneeMasterOffset_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_gainOffsetKneeMasterOffset_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gainOffsetKneeMasterOffset_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_LUTEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_LUTEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->LUTEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_LUTMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyILUTMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_LUTMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyILUTMode *)& ((arg1)->LUTMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_LUTInterpolationMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyILUTInterpolationMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_LUTInterpolationMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyILUTInterpolationMode *)& ((arg1)->LUTInterpolationMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_LUTImplementation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyILUTImplementation *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_LUTImplementation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyILUTImplementation *)& ((arg1)->LUTImplementation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_LUTMappingHardware_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyILUTMapping *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_LUTMappingHardware_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyILUTMapping *)& ((arg1)->LUTMappingHardware); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_LUTMappingSoftware_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyILUTMapping *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_LUTMappingSoftware_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyILUTMapping *)& ((arg1)->LUTMappingSoftware); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_tapSortEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_tapSortEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->tapSortEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_channelSplitEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_channelSplitEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->channelSplitEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_channelSplitMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIChannelSplitMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_channelSplitMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIChannelSplitMode *)& ((arg1)->channelSplitMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_channelSplitChannelIndex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_channelSplitChannelIndex_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->channelSplitChannelIndex); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_channelSplitDeinterlaceEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_channelSplitDeinterlaceEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->channelSplitDeinterlaceEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistInputCorrectionMatrixEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistInputCorrectionMatrixEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->colorTwistInputCorrectionMatrixEnable);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistInputCorrectionMatrixMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIColorTwistInputCorrectionMatrixMode *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistInputCorrectionMatrixMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIColorTwistInputCorrectionMatrixMode *)& ((arg1)->colorTwistInputCorrectionMatrixMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistInputCorrectionMatrixRow0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistInputCorrectionMatrixRow0_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistInputCorrectionMatrixRow0); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistInputCorrectionMatrixRow1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistInputCorrectionMatrixRow1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistInputCorrectionMatrixRow1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistInputCorrectionMatrixRow2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistInputCorrectionMatrixRow2_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistInputCorrectionMatrixRow2); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->colorTwistEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistRow0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistRow0_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistRow0); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistRow1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistRow1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistRow1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistRow2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistRow2_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistRow2); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistOutputCorrectionMatrixEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->colorTwistOutputCorrectionMatrixEnable);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIColorTwistOutputCorrectionMatrixMode *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistOutputCorrectionMatrixMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIColorTwistOutputCorrectionMatrixMode *)& ((arg1)->colorTwistOutputCorrectionMatrixMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixRow0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistOutputCorrectionMatrixRow0_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistOutputCorrectionMatrixRow0); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixRow1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistOutputCorrectionMatrixRow1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistOutputCorrectionMatrixRow1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixRow2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistOutputCorrectionMatrixRow2_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistOutputCorrectionMatrixRow2); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistResultingMatrixRow0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistResultingMatrixRow0_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistResultingMatrixRow0); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistResultingMatrixRow1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistResultingMatrixRow1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistResultingMatrixRow1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_colorTwistResultingMatrixRow2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_colorTwistResultingMatrixRow2_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTwistResultingMatrixRow2); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_formatReinterpreterEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_formatReinterpreterEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->formatReinterpreterEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_formatReinterpreterMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIImageBufferFormatReinterpreterMode *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_formatReinterpreterMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIImageBufferFormatReinterpreterMode *)& ((arg1)->formatReinterpreterMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_formatReinterpreterBayerMosaicParity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBayerMosaicParity *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_formatReinterpreterBayerMosaicParity_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBayerMosaicParity *)& ((arg1)->formatReinterpreterBayerMosaicParity);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_rotationEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_rotationEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->rotationEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_rotationAngle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_rotationAngle_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->rotationAngle); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_setSaturation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ; double arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "ImageProcessing_setSaturation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_setSaturation" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageProcessing_setSaturation" "', argument " "2"" of type '" "double""'"); }
    arg2 = static_cast< double >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->setSaturation(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_getGainOffsetKneeParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::GainOffsetKneeChannelParameters *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "ImageProcessing_getGainOffsetKneeParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_getGainOffsetKneeParameter" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageProcessing_getGainOffsetKneeParameter" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GainOffsetKneeChannelParameters *) &((mvIMPACT::acquire::ImageProcessing const *)arg1)->getGainOffsetKneeParameter(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GainOffsetKneeChannelParameters, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_getGainOffsetKneeParameterCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_getGainOffsetKneeParameterCount" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::ImageProcessing const *)arg1)->getGainOffsetKneeParameterCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_getMirrorParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::MirrorParameters *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "ImageProcessing_getMirrorParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_getMirrorParameter" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageProcessing_getMirrorParameter" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::MirrorParameters *) &((mvIMPACT::acquire::ImageProcessing const *)arg1)->getMirrorParameter(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__MirrorParameters, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_getMirrorParameterCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_getMirrorParameterCount" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::ImageProcessing const *)arg1)->getMirrorParameterCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_getLUTParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::LUTParameters *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "ImageProcessing_getLUTParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_getLUTParameter" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageProcessing_getLUTParameter" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::LUTParameters *) &((mvIMPACT::acquire::ImageProcessing const *)arg1)->getLUTParameter(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__LUTParameters, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_getLUTParameterCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_getLUTParameterCount" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::ImageProcessing const *)arg1)->getLUTParameterCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_getWBUserSetting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::WhiteBalanceSettings *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "ImageProcessing_getWBUserSetting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_getWBUserSetting" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageProcessing_getWBUserSetting" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::WhiteBalanceSettings *) &((mvIMPACT::acquire::ImageProcessing const *)arg1)->getWBUserSetting(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageProcessing_getWBUserSettingsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageProcessing *arg1 = (mvIMPACT::acquire::ImageProcessing *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageProcessing_getWBUserSettingsCount" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageProcessing const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageProcessing * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::ImageProcessing const *)arg1)->getWBUserSettingsCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ImageProcessing_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImageProcessing_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_WhiteBalancer_highQualityWhiteBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WhiteBalancer_highQualityWhiteBalance" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT::acquire::WhiteBalancer::highQualityWhiteBalance(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_WhiteBalancer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::WhiteBalancer *result = 0 ; if (!SWIG_Python_UnpackTuple(args, "new_WhiteBalancer", 0, 0, 0)) SWIG_fail; {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::WhiteBalancer *)new mvIMPACT::acquire::WhiteBalancer();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__WhiteBalancer, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_WhiteBalancer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::WhiteBalancer *arg1 = (mvIMPACT::acquire::WhiteBalancer *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__WhiteBalancer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WhiteBalancer" "', argument " "1"" of type '" "mvIMPACT::acquire::WhiteBalancer *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::WhiteBalancer * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *WhiteBalancer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__WhiteBalancer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *WhiteBalancer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Statistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::Statistics *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Statistics" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Statistics *)new mvIMPACT::acquire::Statistics(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Statistics, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_reset" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::Statistics const *)arg1)->reset(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_captureTime_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_captureTime_s_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->captureTime_s); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_bandwidthConsumed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_bandwidthConsumed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->bandwidthConsumed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_errorCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_errorCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->errorCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_abortedRequestsCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_abortedRequestsCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->abortedRequestsCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_timedOutRequestsCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_timedOutRequestsCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->timedOutRequestsCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_framesPerSecond_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_framesPerSecond_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->framesPerSecond); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_frameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_frameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->frameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_imageProcTime_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_imageProcTime_s_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->imageProcTime_s); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_formatConvertTime_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_formatConvertTime_s_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->formatConvertTime_s); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_queueTime_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_queueTime_s_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->queueTime_s); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_lostImagesCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_lostImagesCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->lostImagesCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_framesIncompleteCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_framesIncompleteCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->framesIncompleteCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_missingDataAverage_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_missingDataAverage_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->missingDataAverage_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Statistics_retransmitCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_retransmitCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->retransmitCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_Statistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Statistics *arg1 = (mvIMPACT::acquire::Statistics *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Statistics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Statistics" "', argument " "1"" of type '" "mvIMPACT::acquire::Statistics *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Statistics * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *Statistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__Statistics, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Statistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FullSettingsBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::FullSettingsBase *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FullSettingsBase" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FullSettingsBase" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FullSettingsBase" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::FullSettingsBase *)new mvIMPACT::acquire::FullSettingsBase(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FullSettingsBase, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_FullSettingsBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::FullSettingsBase *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FullSettingsBase" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::FullSettingsBase *)new mvIMPACT::acquire::FullSettingsBase(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FullSettingsBase, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FullSettingsBase(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FullSettingsBase", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_FullSettingsBase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_FullSettingsBase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FullSettingsBase'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FullSettingsBase::FullSettingsBase(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::FullSettingsBase::FullSettingsBase(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_FullSettingsBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::FullSettingsBase *arg1 = (mvIMPACT::acquire::FullSettingsBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FullSettingsBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FullSettingsBase" "', argument " "1"" of type '" "mvIMPACT::acquire::FullSettingsBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FullSettingsBase * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FullSettingsBase_imageProcessing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FullSettingsBase *arg1 = (mvIMPACT::acquire::FullSettingsBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::ImageProcessing *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FullSettingsBase, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FullSettingsBase_imageProcessing_get" "', argument " "1"" of type '" "mvIMPACT::acquire::FullSettingsBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FullSettingsBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::ImageProcessing *)& ((arg1)->imageProcessing); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FullSettingsBase_imageDestination_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FullSettingsBase *arg1 = (mvIMPACT::acquire::FullSettingsBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::ImageDestination *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FullSettingsBase, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FullSettingsBase_imageDestination_get" "', argument " "1"" of type '" "mvIMPACT::acquire::FullSettingsBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FullSettingsBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::ImageDestination *)& ((arg1)->imageDestination); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageDestination, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FullSettingsBase_basedOn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FullSettingsBase *arg1 = (mvIMPACT::acquire::FullSettingsBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FullSettingsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FullSettingsBase_basedOn_get" "', argument " "1"" of type '" "mvIMPACT::acquire::FullSettingsBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FullSettingsBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->basedOn); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *FullSettingsBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__FullSettingsBase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FullSettingsBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SystemSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::SystemSettings *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SystemSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::SystemSettings *)new mvIMPACT::acquire::SystemSettings(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_requestCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_requestCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->requestCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_acquisitionMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAcquisitionMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_acquisitionMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAcquisitionMode *)& ((arg1)->acquisitionMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_acquisitionIdleTimeMax_ms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_acquisitionIdleTimeMax_ms_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->acquisitionIdleTimeMax_ms); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_imageProcessingMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIImageProcessingMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_imageProcessingMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIImageProcessingMode *)& ((arg1)->imageProcessingMode); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_imageProcessingMaximumThreadCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_imageProcessingMaximumThreadCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageProcessingMaximumThreadCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_imageProcessingOptimization_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIImageProcessingOptimization *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_imageProcessingOptimization_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIImageProcessingOptimization *)& ((arg1)->imageProcessingOptimization);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_featurePollingEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_featurePollingEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->featurePollingEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_featurePollingInterval_ms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_featurePollingInterval_ms_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->featurePollingInterval_ms); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_methodPollingInterval_ms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_methodPollingInterval_ms_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->methodPollingInterval_ms); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemSettings_methodPollingMaxRetryCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemSettings_methodPollingMaxRetryCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->methodPollingMaxRetryCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SystemSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SystemSettings *arg1 = (mvIMPACT::acquire::SystemSettings *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SystemSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__SystemSettings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SystemSettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ImageMemoryManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::ImageMemoryManager *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageMemoryManager" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::ImageMemoryManager *)new mvIMPACT::acquire::ImageMemoryManager(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageMemoryManager_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageMemoryManager *arg1 = (mvIMPACT::acquire::ImageMemoryManager *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIMemoryManagerMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageMemoryManager_mode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageMemoryManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageMemoryManager * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIMemoryManagerMode *)& ((arg1)->mode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageMemoryManager_allocatedDMAMemory_bytes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageMemoryManager *arg1 = (mvIMPACT::acquire::ImageMemoryManager *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageMemoryManager_allocatedDMAMemory_bytes_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageMemoryManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageMemoryManager * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->allocatedDMAMemory_bytes); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageMemoryManager_usedDMAMemory_bytes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageMemoryManager *arg1 = (mvIMPACT::acquire::ImageMemoryManager *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageMemoryManager_usedDMAMemory_bytes_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageMemoryManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageMemoryManager * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->usedDMAMemory_bytes); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageMemoryManager_usedBlocks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageMemoryManager *arg1 = (mvIMPACT::acquire::ImageMemoryManager *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageMemoryManager_usedBlocks_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageMemoryManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageMemoryManager * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->usedBlocks); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageMemoryManager_poolMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageMemoryManager *arg1 = (mvIMPACT::acquire::ImageMemoryManager *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIMemoryManagerPoolMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageMemoryManager_poolMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageMemoryManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageMemoryManager * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIMemoryManagerPoolMode *)& ((arg1)->poolMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageMemoryManager_poolBlockSize_bytes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageMemoryManager *arg1 = (mvIMPACT::acquire::ImageMemoryManager *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageMemoryManager_poolBlockSize_bytes_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageMemoryManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageMemoryManager * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->poolBlockSize_bytes); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageMemoryManager_poolBlockCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ImageMemoryManager *arg1 = (mvIMPACT::acquire::ImageMemoryManager *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageMemoryManager_poolBlockCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageMemoryManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageMemoryManager * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->poolBlockCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ImageMemoryManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::ImageMemoryManager *arg1 = (mvIMPACT::acquire::ImageMemoryManager *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageMemoryManager" "', argument " "1"" of type '" "mvIMPACT::acquire::ImageMemoryManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ImageMemoryManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ImageMemoryManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImageMemoryManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InfoBlueDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::InfoBlueDevice *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InfoBlueDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::InfoBlueDevice *)new mvIMPACT::acquire::InfoBlueDevice(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__InfoBlueDevice, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueDevice_sensorXRes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueDevice *arg1 = (mvIMPACT::acquire::InfoBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueDevice, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueDevice_sensorXRes_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->sensorXRes); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueDevice_sensorYRes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueDevice *arg1 = (mvIMPACT::acquire::InfoBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueDevice, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueDevice_sensorYRes_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->sensorYRes); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueDevice_sensorColorMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueDevice *arg1 = (mvIMPACT::acquire::InfoBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIInfoSensorColorMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueDevice_sensorColorMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIInfoSensorColorMode *)& ((arg1)->sensorColorMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueDevice_sensorType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueDevice *arg1 = (mvIMPACT::acquire::InfoBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIInfoSensorType *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueDevice_sensorType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIInfoSensorType *)& ((arg1)->sensorType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_InfoBlueDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::InfoBlueDevice *arg1 = (mvIMPACT::acquire::InfoBlueDevice *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueDevice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InfoBlueDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueDevice * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *InfoBlueDevice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__InfoBlueDevice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InfoBlueDevice_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InfoBlueCOUGAR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::InfoBlueCOUGAR *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InfoBlueCOUGAR" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::InfoBlueCOUGAR *)new mvIMPACT::acquire::InfoBlueCOUGAR(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__InfoBlueCOUGAR, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueCOUGAR_deviceFPGAVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueCOUGAR *arg1 = (mvIMPACT::acquire::InfoBlueCOUGAR *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueCOUGAR, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueCOUGAR_deviceFPGAVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceFPGAVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_InfoBlueCOUGAR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::InfoBlueCOUGAR *arg1 = (mvIMPACT::acquire::InfoBlueCOUGAR *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueCOUGAR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InfoBlueCOUGAR" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueCOUGAR * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *InfoBlueCOUGAR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__InfoBlueCOUGAR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InfoBlueCOUGAR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InfoBlueFOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::InfoBlueFOX *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InfoBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::InfoBlueFOX *)new mvIMPACT::acquire::InfoBlueFOX(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueFOX_firmwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueFOX *arg1 = (mvIMPACT::acquire::InfoBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueFOX_firmwareVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->firmwareVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueFOX_sensorFPGAVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueFOX *arg1 = (mvIMPACT::acquire::InfoBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueFOX_sensorFPGAVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->sensorFPGAVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueFOX_sensorCaps_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::InfoBlueFOX *arg1 = (mvIMPACT::acquire::InfoBlueFOX *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBlueFOXInfoSensorCapabilities *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueFOX_sensorCaps_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBlueFOXInfoSensorCapabilities *)& ((arg1)->sensorCaps); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueFOX_deviceSensorRevision_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueFOX *arg1 = (mvIMPACT::acquire::InfoBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueFOX_deviceSensorRevision_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceSensorRevision); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueFOX_userEEPROMSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueFOX *arg1 = (mvIMPACT::acquire::InfoBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueFOX_userEEPROMSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->userEEPROMSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueFOX_deviceTemperature_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::InfoBlueFOX *arg1 = (mvIMPACT::acquire::InfoBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBlueFOX_deviceTemperature_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->deviceTemperature); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_InfoBlueFOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::InfoBlueFOX *arg1 = (mvIMPACT::acquire::InfoBlueFOX *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InfoBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueFOX * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *InfoBlueFOX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InfoBlueFOX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DigitalInput_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalInput *arg1 = (mvIMPACT::acquire::DigitalInput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalInput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalInput_get" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalInput const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalInput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::DigitalInput const *)arg1)->get(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalInput_getDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DigitalInput *arg1 = (mvIMPACT::acquire::DigitalInput *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalInput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalInput_getDescription" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalInput const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalInput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::DigitalInput const *)arg1)->getDescription(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_DigitalInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalInput *arg1 = (mvIMPACT::acquire::DigitalInput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalInput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DigitalInput" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalInput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalInput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *DigitalInput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__DigitalInput, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_DigitalOutput_flip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalOutput *arg1 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalOutput_flip" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)(arg1)->flip(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalOutput_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalOutput *arg1 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalOutput_get" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::DigitalOutput const *)arg1)->get(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalOutput_getIsWriteable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DigitalOutput *arg1 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalOutput_getIsWriteable" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::DigitalOutput const *)arg1)->isWriteable(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalOutput_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalOutput *arg1 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalOutput_set" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set(); SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalOutput_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalOutput *arg1 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalOutput_reset" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->reset(); SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalOutput_getDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DigitalOutput *arg1 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalOutput_getDescription" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::DigitalOutput const *)arg1)->getDescription(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalOutput_setState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalOutput *arg1 = (mvIMPACT::acquire::DigitalOutput *) 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  bool val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "DigitalOutput_setState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalOutput_setState" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DigitalOutput_setState" "', argument " "2"" of type '" "bool""'"); }
    arg2 = static_cast< bool >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        mvIMPACT_acquire_DigitalOutput_setState(arg1,arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_DigitalOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalOutput *arg1 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DigitalOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *DigitalOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SyncOutput_frequency_Hz_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SyncOutput *arg1 = (mvIMPACT::acquire::SyncOutput *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SyncOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyncOutput_frequency_Hz_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SyncOutput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SyncOutput * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->frequency_Hz); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SyncOutput_lowPart_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SyncOutput *arg1 = (mvIMPACT::acquire::SyncOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SyncOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyncOutput_lowPart_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SyncOutput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SyncOutput * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->lowPart_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SyncOutput_getDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SyncOutput *arg1 = (mvIMPACT::acquire::SyncOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SyncOutput, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyncOutput_getDescription" "', argument " "1"" of type '" "mvIMPACT::acquire::SyncOutput const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SyncOutput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::SyncOutput const *)arg1)->getDescription(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SyncOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SyncOutput *arg1 = (mvIMPACT::acquire::SyncOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SyncOutput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SyncOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::SyncOutput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SyncOutput * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SyncOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__SyncOutput, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_RTCtrProgramStep_address_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgramStep_address_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->address); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgramStep_frameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgramStep_frameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->frameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgramStep_clocks_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgramStep_clocks_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->clocks_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgramStep_digitalInputs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDigIOState *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgramStep_digitalInputs_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDigIOState *)& ((arg1)->digitalInputs); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgramStep_digitalOutputs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDigIOState *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgramStep_digitalOutputs_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDigIOState *)& ((arg1)->digitalOutputs); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgramStep_sensorHeads_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDigIOState *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgramStep_sensorHeads_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDigIOState *)& ((arg1)->sensorHeads); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgramStep_opCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIRTProgOpCodes *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgramStep_opCode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIRTProgOpCodes *)& ((arg1)->opCode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgramStep_controllerRegister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgramStep_controllerRegister_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->controllerRegister); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgramStep_registerValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgramStep_registerValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->registerValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_RTCtrProgramStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RTCtrProgramStep *arg1 = (mvIMPACT::acquire::RTCtrProgramStep *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RTCtrProgramStep" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgramStep *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgramStep * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *RTCtrProgramStep_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RTCtrProgram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RTCtrProgram *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::RTCtrProgram *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RTCtrProgram" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RTCtrProgram" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::RTCtrProgram *)new mvIMPACT::acquire::RTCtrProgram((mvIMPACT::acquire::RTCtrProgram const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_RTCtrProgram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RTCtrProgram *arg1 = (mvIMPACT::acquire::RTCtrProgram *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RTCtrProgram" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgram_setProgramSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgram *arg1 = (mvIMPACT::acquire::RTCtrProgram *) 0 ; int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "RTCtrProgram_setProgramSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgram_setProgramSize" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTCtrProgram_setProgramSize" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->setProgramSize(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgram_getProgramSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgram *arg1 = (mvIMPACT::acquire::RTCtrProgram *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgram_getProgramSize" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::RTCtrProgram const *)arg1)->getProgramSize(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgram_programStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RTCtrProgram *arg1 = (mvIMPACT::acquire::RTCtrProgram *) 0 ; unsigned int arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::RTCtrProgramStep *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "RTCtrProgram_programStep", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgram_programStep" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTCtrProgram_programStep" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::RTCtrProgramStep *)((mvIMPACT::acquire::RTCtrProgram const *)arg1)->programStep(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgram_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RTCtrProgram *arg1 = (mvIMPACT::acquire::RTCtrProgram *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIRTCtrlModes *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgram_mode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIRTCtrlModes *)& ((arg1)->mode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgram_filename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RTCtrProgram *arg1 = (mvIMPACT::acquire::RTCtrProgram *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgram_filename_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->filename); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgram_programState_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::RTCtrProgram *arg1 = (mvIMPACT::acquire::RTCtrProgram *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgram_programState_get" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->programState); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgram_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RTCtrProgram *arg1 = (mvIMPACT::acquire::RTCtrProgram *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgram_load" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->load(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_RTCtrProgram_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RTCtrProgram *arg1 = (mvIMPACT::acquire::RTCtrProgram *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCtrProgram_save" "', argument " "1"" of type '" "mvIMPACT::acquire::RTCtrProgram *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::RTCtrProgram * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->save(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *RTCtrProgram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RTCtrProgram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_PulseStartConfiguration_number(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PulseStartConfiguration *arg1 = (mvIMPACT::acquire::PulseStartConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PulseStartConfiguration_number" "', argument " "1"" of type '" "mvIMPACT::acquire::PulseStartConfiguration const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PulseStartConfiguration * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::PulseStartConfiguration const *)arg1)->number(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PulseStartConfiguration_pulseStartTrigger_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PulseStartConfiguration *arg1 = (mvIMPACT::acquire::PulseStartConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIPulseStartTrigger *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PulseStartConfiguration_pulseStartTrigger_get" "', argument " "1"" of type '" "mvIMPACT::acquire::PulseStartConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PulseStartConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIPulseStartTrigger *)& ((arg1)->pulseStartTrigger); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PulseStartConfiguration_digitalSignal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PulseStartConfiguration *arg1 = (mvIMPACT::acquire::PulseStartConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDigitalSignal *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PulseStartConfiguration_digitalSignal_get" "', argument " "1"" of type '" "mvIMPACT::acquire::PulseStartConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PulseStartConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDigitalSignal *)& ((arg1)->digitalSignal); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PulseStartConfiguration_divider_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PulseStartConfiguration *arg1 = (mvIMPACT::acquire::PulseStartConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PulseStartConfiguration_divider_get" "', argument " "1"" of type '" "mvIMPACT::acquire::PulseStartConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PulseStartConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->divider); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PulseStartConfiguration_frequency_Hz_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PulseStartConfiguration *arg1 = (mvIMPACT::acquire::PulseStartConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PulseStartConfiguration_frequency_Hz_get" "', argument " "1"" of type '" "mvIMPACT::acquire::PulseStartConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PulseStartConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->frequency_Hz); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PulseStartConfiguration_triggerMoment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PulseStartConfiguration *arg1 = (mvIMPACT::acquire::PulseStartConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyITriggerMoment *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PulseStartConfiguration_triggerMoment_get" "', argument " "1"" of type '" "mvIMPACT::acquire::PulseStartConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PulseStartConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyITriggerMoment *)& ((arg1)->triggerMoment); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_PulseStartConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PulseStartConfiguration *arg1 = (mvIMPACT::acquire::PulseStartConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PulseStartConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::PulseStartConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::PulseStartConfiguration * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PulseStartConfiguration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_IOSubSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOSubSystem" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_getPulseStartConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::PulseStartConfiguration *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "IOSubSystem_getPulseStartConfiguration", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_getPulseStartConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystem_getPulseStartConfiguration" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::PulseStartConfiguration *)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getPulseStartConfiguration(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_getPulseStartConfigurationCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_getPulseStartConfigurationCount" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getPulseStartConfigurationCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_getRTCtrProgram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::RTCtrProgram *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "IOSubSystem_getRTCtrProgram", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_getRTCtrProgram" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystem_getRTCtrProgram" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::RTCtrProgram *)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getRTCtrProgram(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_getRTCtrProgramCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_getRTCtrProgramCount" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->RTCtrProgramCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_getInputCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_getInputCount" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getInputCount(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_readInputRegister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_readInputRegister" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->readInputRegister();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_getInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; unsigned int arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::DigitalInput *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "IOSubSystem_getInput", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_getInput" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystem_getInput" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::DigitalInput *)((mvIMPACT::acquire::IOSubSystem const *)arg1)->input(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DigitalInput, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_getOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; unsigned int arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::DigitalOutput *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "IOSubSystem_getOutput", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_getOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystem_getOutput" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::DigitalOutput *)((mvIMPACT::acquire::IOSubSystem const *)arg1)->output(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_getOutputCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_getOutputCount" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getOutputCount(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_readOutputRegister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_readOutputRegister" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->readOutputRegister();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_writeOutputRegister__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; unsigned int arg2 ;
  unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; unsigned int val3 ; int ecode3 = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_writeOutputRegister" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystem_writeOutputRegister" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IOSubSystem_writeOutputRegister" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->writeOutputRegister(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_writeOutputRegister__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystem *arg1 = (mvIMPACT::acquire::IOSubSystem *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystem_writeOutputRegister" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystem *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystem * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystem_writeOutputRegister" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->writeOutputRegister(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_writeOutputRegister(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "IOSubSystem_writeOutputRegister", 0, 3, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_IOSubSystem_writeOutputRegister__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_IOSubSystem_writeOutputRegister__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IOSubSystem_writeOutputRegister'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::IOSubSystem::writeOutputRegister(unsigned int,unsigned int)\n"
  "    mvIMPACT::acquire::IOSubSystem::writeOutputRegister(unsigned int)\n"); return 0; }
SWIGINTERN PyObject *IOSubSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__IOSubSystem, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IOSubSystemBlueFOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::IOSubSystemBlueFOX *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOSubSystemBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::IOSubSystemBlueFOX *)new mvIMPACT::acquire::IOSubSystemBlueFOX(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_readInputRegisterAtomic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemBlueFOX *arg1 = (mvIMPACT::acquire::IOSubSystemBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemBlueFOX_readInputRegisterAtomic" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueFOX const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueFOX * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystemBlueFOX const *)arg1)->readInputRegisterAtomic();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_readOutputRegisterAtomic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemBlueFOX *arg1 = (mvIMPACT::acquire::IOSubSystemBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemBlueFOX_readOutputRegisterAtomic" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueFOX const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueFOX * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystemBlueFOX const *)arg1)->readOutputRegisterAtomic();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegister__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemBlueFOX *arg1 = (mvIMPACT::acquire::IOSubSystemBlueFOX *) 0 ;
  unsigned int arg2 ; unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  unsigned int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemBlueFOX_writeOutputRegister" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueFOX * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystemBlueFOX_writeOutputRegister" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IOSubSystemBlueFOX_writeOutputRegister" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->writeOutputRegister(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegister__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemBlueFOX *arg1 = (mvIMPACT::acquire::IOSubSystemBlueFOX *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemBlueFOX_writeOutputRegister" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueFOX * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystemBlueFOX_writeOutputRegister" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->writeOutputRegister(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegister(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "IOSubSystemBlueFOX_writeOutputRegister", 0, 3, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_IOSubSystemBlueFOX_writeOutputRegister__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_IOSubSystemBlueFOX_writeOutputRegister__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IOSubSystemBlueFOX_writeOutputRegister'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::IOSubSystemBlueFOX::writeOutputRegister(unsigned int,unsigned int)\n"
  "    mvIMPACT::acquire::IOSubSystemBlueFOX::writeOutputRegister(unsigned int)\n"); return 0; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemBlueFOX *arg1 = (mvIMPACT::acquire::IOSubSystemBlueFOX *) 0 ;
  unsigned int arg2 ; unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  unsigned int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemBlueFOX_writeOutputRegisterAtomic" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueFOX * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystemBlueFOX_writeOutputRegisterAtomic" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IOSubSystemBlueFOX_writeOutputRegisterAtomic" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->writeOutputRegisterAtomic(arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemBlueFOX *arg1 = (mvIMPACT::acquire::IOSubSystemBlueFOX *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemBlueFOX_writeOutputRegisterAtomic" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueFOX * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystemBlueFOX_writeOutputRegisterAtomic" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->writeOutputRegisterAtomic(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "IOSubSystemBlueFOX_writeOutputRegisterAtomic", 0, 3, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IOSubSystemBlueFOX_writeOutputRegisterAtomic'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::IOSubSystemBlueFOX::writeOutputRegisterAtomic(unsigned int,unsigned int)\n"
  "    mvIMPACT::acquire::IOSubSystemBlueFOX::writeOutputRegisterAtomic(unsigned int)\n"); return 0; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_digitalInputThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemBlueFOX *arg1 = (mvIMPACT::acquire::IOSubSystemBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIBlueFOXDigitalInputThreshold *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemBlueFOX_digitalInputThreshold_get" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBlueFOXDigitalInputThreshold *)& ((arg1)->digitalInputThreshold);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_IOSubSystemBlueFOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::IOSubSystemBlueFOX *arg1 = (mvIMPACT::acquire::IOSubSystemBlueFOX *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOSubSystemBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueFOX * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *IOSubSystemBlueFOX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IOSubSystemBlueFOX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IOSubSystemCommon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::IOSubSystemCommon *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOSubSystemCommon" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::IOSubSystemCommon *)new mvIMPACT::acquire::IOSubSystemCommon(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemCommon, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemCommon_writeOutputRegister__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemCommon *arg1 = (mvIMPACT::acquire::IOSubSystemCommon *) 0 ;
  unsigned int arg2 ; unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  unsigned int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemCommon, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemCommon_writeOutputRegister" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemCommon *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemCommon * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystemCommon_writeOutputRegister" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IOSubSystemCommon_writeOutputRegister" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->writeOutputRegister(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemCommon_writeOutputRegister__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemCommon *arg1 = (mvIMPACT::acquire::IOSubSystemCommon *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemCommon, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemCommon_writeOutputRegister" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemCommon *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemCommon * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystemCommon_writeOutputRegister" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->writeOutputRegister(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemCommon_writeOutputRegister(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "IOSubSystemCommon_writeOutputRegister", 0, 3, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_IOSubSystemCommon_writeOutputRegister__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_IOSubSystemCommon_writeOutputRegister__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IOSubSystemCommon_writeOutputRegister'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::IOSubSystemCommon::writeOutputRegister(unsigned int,unsigned int)\n"
  "    mvIMPACT::acquire::IOSubSystemCommon::writeOutputRegister(unsigned int)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_IOSubSystemCommon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::IOSubSystemCommon *arg1 = (mvIMPACT::acquire::IOSubSystemCommon *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemCommon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOSubSystemCommon" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemCommon *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemCommon * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *IOSubSystemCommon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemCommon, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IOSubSystemCommon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OutputSignalGeneratorBlueDevice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutputSignalGeneratorBlueDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *)new mvIMPACT::acquire::OutputSignalGeneratorBlueDevice(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_OutputSignalGeneratorBlueDevice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutputSignalGeneratorBlueDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OutputSignalGeneratorBlueDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *)new mvIMPACT::acquire::OutputSignalGeneratorBlueDevice((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_OutputSignalGeneratorBlueDevice(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OutputSignalGeneratorBlueDevice", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 1) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Device, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_1; return _wrap_new_OutputSignalGeneratorBlueDevice__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 1) { PyObject *retobj = _wrap_new_OutputSignalGeneratorBlueDevice__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OutputSignalGeneratorBlueDevice'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorBlueDevice::OutputSignalGeneratorBlueDevice(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorBlueDevice::OutputSignalGeneratorBlueDevice(mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_OutputSignalGeneratorBlueDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OutputSignalGeneratorBlueDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_undefineSignal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; int result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorBlueDevice_undefineSignal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorBlueDevice_undefineSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorBlueDevice_undefineSignal" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->undefineSignal(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_canCreateExposeActiveSignal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorBlueDevice_canCreateExposeActiveSignal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorBlueDevice_canCreateExposeActiveSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorBlueDevice_canCreateExposeActiveSignal" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->canCreateExposeActiveSignal(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_canInvertSignal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorBlueDevice_canInvertSignal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorBlueDevice_canInvertSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorBlueDevice_canInvertSignal" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->canInvertSignal(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_getOutputMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::TDeviceDigitalOutputMode result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorBlueDevice_getOutputMode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorBlueDevice_getOutputMode" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorBlueDevice_getOutputMode" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->getOutputMode(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_isOutputModeActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ;
  mvIMPACT::acquire::TDeviceDigitalOutputMode arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  int val3 ; int ecode3 = 0 ; PyObject *swig_obj[3] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorBlueDevice_isOutputModeActive", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorBlueDevice_isOutputModeActive" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorBlueDevice_isOutputModeActive" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorBlueDevice_isOutputModeActive" "', argument " "3"" of type '" "mvIMPACT::acquire::TDeviceDigitalOutputMode""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDeviceDigitalOutputMode >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->isOutputModeActive(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_isSignalInverted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorBlueDevice_isSignalInverted", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorBlueDevice_isSignalInverted" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorBlueDevice_isSignalInverted" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->isSignalInverted(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_setOutputMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ;
  mvIMPACT::acquire::TDeviceDigitalOutputMode arg3 ; bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; int val3 ; int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; int result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorBlueDevice_setOutputMode" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorBlueDevice_setOutputMode" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorBlueDevice_setOutputMode" "', argument " "3"" of type '" "mvIMPACT::acquire::TDeviceDigitalOutputMode""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDeviceDigitalOutputMode >(val3); ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OutputSignalGeneratorBlueDevice_setOutputMode" "', argument " "4"" of type '" "bool""'"); }
    arg4 = static_cast< bool >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->setOutputMode(arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_setOutputMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ;
  mvIMPACT::acquire::TDeviceDigitalOutputMode arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  int val3 ; int ecode3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorBlueDevice_setOutputMode" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorBlueDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorBlueDevice_setOutputMode" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorBlueDevice_setOutputMode" "', argument " "3"" of type '" "mvIMPACT::acquire::TDeviceDigitalOutputMode""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDeviceDigitalOutputMode >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->setOutputMode(arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_setOutputMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorBlueDevice_setOutputMode", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 3) { PyObject *retobj = _wrap_OutputSignalGeneratorBlueDevice_setOutputMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_OutputSignalGeneratorBlueDevice_setOutputMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OutputSignalGeneratorBlueDevice_setOutputMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorBlueDevice::setOutputMode(mvIMPACT::acquire::DigitalOutput *,mvIMPACT::acquire::TDeviceDigitalOutputMode,bool)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorBlueDevice::setOutputMode(mvIMPACT::acquire::DigitalOutput *,mvIMPACT::acquire::TDeviceDigitalOutputMode)\n");
  return 0; }
SWIGINTERN PyObject *OutputSignalGeneratorBlueDevice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OutputSignalGeneratorBlueDevice_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IOSubSystemFrameGrabber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::IOSubSystemFrameGrabber *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOSubSystemFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::IOSubSystemFrameGrabber *)new mvIMPACT::acquire::IOSubSystemFrameGrabber(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemFrameGrabber_getHDOutputCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemFrameGrabber *arg1 = (mvIMPACT::acquire::IOSubSystemFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemFrameGrabber_getHDOutputCount" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemFrameGrabber * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystemFrameGrabber const *)arg1)->getHDOutputCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemFrameGrabber_HDOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemFrameGrabber *arg1 = (mvIMPACT::acquire::IOSubSystemFrameGrabber *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::SyncOutput *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "IOSubSystemFrameGrabber_HDOutput", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemFrameGrabber_HDOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemFrameGrabber * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystemFrameGrabber_HDOutput" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::SyncOutput *)((mvIMPACT::acquire::IOSubSystemFrameGrabber const *)arg1)->HDOutput(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__SyncOutput, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemFrameGrabber_getVDOutputCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemFrameGrabber *arg1 = (mvIMPACT::acquire::IOSubSystemFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemFrameGrabber_getVDOutputCount" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemFrameGrabber * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystemFrameGrabber const *)arg1)->getVDOutputCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemFrameGrabber_VDOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemFrameGrabber *arg1 = (mvIMPACT::acquire::IOSubSystemFrameGrabber *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::SyncOutput *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "IOSubSystemFrameGrabber_VDOutput", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemFrameGrabber_VDOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemFrameGrabber * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IOSubSystemFrameGrabber_VDOutput" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::SyncOutput *)((mvIMPACT::acquire::IOSubSystemFrameGrabber const *)arg1)->VDOutput(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__SyncOutput, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemFrameGrabber_syncOutputMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemFrameGrabber *arg1 = (mvIMPACT::acquire::IOSubSystemFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDeviceSyncOutMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemFrameGrabber_syncOutputMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceSyncOutMode *)& ((arg1)->syncOutputMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_IOSubSystemFrameGrabber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemFrameGrabber *arg1 = (mvIMPACT::acquire::IOSubSystemFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOSubSystemFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemFrameGrabber * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *IOSubSystemFrameGrabber_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IOSubSystemFrameGrabber_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OutputSignalGeneratorFrameGrabber__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutputSignalGeneratorFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *)new mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_OutputSignalGeneratorFrameGrabber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutputSignalGeneratorFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OutputSignalGeneratorFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *)new mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_OutputSignalGeneratorFrameGrabber(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OutputSignalGeneratorFrameGrabber", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 1) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Device, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_1; return _wrap_new_OutputSignalGeneratorFrameGrabber__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 1) { PyObject *retobj = _wrap_new_OutputSignalGeneratorFrameGrabber__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OutputSignalGeneratorFrameGrabber'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::OutputSignalGeneratorFrameGrabber(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::OutputSignalGeneratorFrameGrabber(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_OutputSignalGeneratorFrameGrabber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OutputSignalGeneratorFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; int arg3 ; int arg4 ; int arg5 ;
  mvIMPACT::acquire::PulseStartConfiguration *arg6 = (mvIMPACT::acquire::PulseStartConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; int result; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "6"" of type '" "mvIMPACT::acquire::PulseStartConfiguration *""'");  }
   arg6 = reinterpret_cast< mvIMPACT::acquire::PulseStartConfiguration * >(argp6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->definePulse(arg2,arg3,arg4,arg5,arg6); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; int arg3 ; int arg4 ; int arg5 ;
  void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; int result; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "OutputSignalGeneratorFrameGrabber_definePulse" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->definePulse(arg2,arg3,arg4,arg5); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulse(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[7] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorFrameGrabber_definePulse", 0, 6, argv))) SWIG_fail; --argc;
  if (argc == 5) { PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_definePulse__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 6) {
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_definePulse__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_definePulse'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePulse(mvIMPACT::acquire::DigitalOutput *,int,int,int,mvIMPACT::acquire::PulseStartConfiguration *)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePulse(mvIMPACT::acquire::DigitalOutput *,int,int,int)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; int arg3 ;
  std::vector< int,std::allocator< int > > *arg4 = 0 ;
  mvIMPACT::acquire::PulseStartConfiguration *arg5 = (mvIMPACT::acquire::PulseStartConfiguration *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; void *argp5 = 0 ; int res5 = 0 ; int result;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_definePulseSequence" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_definePulseSequence" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorFrameGrabber_definePulseSequence" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { if( !PyList_Check(swig_obj[3]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list.");
      SWIG_fail; }  int lsize = PySequence_Length(swig_obj[3]); std::vector<int>* pV = new std::vector<int> (0);
    for( int i = 0; i < lsize; ++i ) { PyObject* objectValue = PyList_GetItem(swig_obj[3], i); if ( NULL == objectValue ) {
        SWIG_fail; }  PyErr_Restore(NULL, NULL, NULL);  int value = PyLong_AsLong(objectValue); if ( NULL != PyErr_Occurred() )
      { SWIG_fail; }  pV->push_back(static_cast<int>(value)); }  arg4 = pV; } 
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OutputSignalGeneratorFrameGrabber_definePulseSequence" "', argument " "5"" of type '" "mvIMPACT::acquire::PulseStartConfiguration *""'");  }
   arg5 = reinterpret_cast< mvIMPACT::acquire::PulseStartConfiguration * >(argp5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->definePulseSequence(arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); { int lsize = PySequence_Length(swig_obj[3]);
    if( -1 == PySequence_DelSlice( swig_obj[3], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int>::const_iterator i = arg4->begin(); i != arg4->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[3], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg4 ); } 
  return resultobj; fail: { delete( arg4 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; int arg3 ;
  std::vector< int,std::allocator< int > > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  int val3 ; int ecode3 = 0 ; int result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_definePulseSequence" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_definePulseSequence" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorFrameGrabber_definePulseSequence" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { if( !PyList_Check(swig_obj[3]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list.");
      SWIG_fail; }  int lsize = PySequence_Length(swig_obj[3]); std::vector<int>* pV = new std::vector<int> (0);
    for( int i = 0; i < lsize; ++i ) { PyObject* objectValue = PyList_GetItem(swig_obj[3], i); if ( NULL == objectValue ) {
        SWIG_fail; }  PyErr_Restore(NULL, NULL, NULL);  int value = PyLong_AsLong(objectValue); if ( NULL != PyErr_Occurred() )
      { SWIG_fail; }  pV->push_back(static_cast<int>(value)); }  arg4 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->definePulseSequence(arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); { int lsize = PySequence_Length(swig_obj[3]);
    if( -1 == PySequence_DelSlice( swig_obj[3], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int>::const_iterator i = arg4->begin(); i != arg4->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[3], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg4 ); } 
  return resultobj; fail: { delete( arg4 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorFrameGrabber_definePulseSequence", 0, 5, argv))) SWIG_fail;
  --argc; if (argc == 4) {
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_definePulseSequence'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePulseSequence(mvIMPACT::acquire::DigitalOutput *,int,std::vector< int,std::allocator< int > > const &,mvIMPACT::acquire::PulseStartConfiguration *)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePulseSequence(mvIMPACT::acquire::DigitalOutput *,int,std::vector< int,std::allocator< int > > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ;
  mvIMPACT::acquire::TDigitalSignalTranslationDict *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  void *argp3 = 0 ; int res3 = 0 ; PyObject *swig_obj[3] ; int result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_std__allocatorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes" "', argument " "3"" of type '" "mvIMPACT::acquire::TDigitalSignalTranslationDict &""'");  }
   if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes" "', argument " "3"" of type '" "mvIMPACT::acquire::TDigitalSignalTranslationDict &""'"); }
   arg3 = reinterpret_cast< mvIMPACT::acquire::TDigitalSignalTranslationDict * >(argp3); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidSignalsForPassThroughModes(arg2,*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; unsigned int result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalCount" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalCount" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalCount(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::TDigitalSignal result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalValue(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; mvIMPACT::acquire::TDigitalSignal result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue", 0, 3, argv))) SWIG_fail;
  --argc; if (argc == 2) {
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalValue(mvIMPACT::acquire::DigitalOutput *,int) const\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalValue(mvIMPACT::acquire::DigitalOutput *) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; std::string result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalString(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; std::string result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString", 0, 3, argv))) SWIG_fail;
  --argc; if (argc == 2) {
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalString(mvIMPACT::acquire::DigitalOutput *,int) const\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalString(mvIMPACT::acquire::DigitalOutput *) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; mvIMPACT::acquire::TDigitalSignal arg3 ;
  bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; bool val4 ;
  int ecode4 = 0 ; int result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "3"" of type '" "mvIMPACT::acquire::TDigitalSignal""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDigitalSignal >(val3); ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "4"" of type '" "bool""'"); }
    arg4 = static_cast< bool >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->definePassThroughSignal(arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; mvIMPACT::acquire::TDigitalSignal arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; int result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "3"" of type '" "mvIMPACT::acquire::TDigitalSignal""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDigitalSignal >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->definePassThroughSignal(arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; std::string *arg3 = 0 ; bool arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int res3 = SWIG_OLDOBJ ; bool val4 ; int ecode4 = 0 ;
  int result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "4"" of type '" "bool""'"); }
    arg4 = static_cast< bool >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->definePassThroughSignal(arg2,(std::string const &)*arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail:
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; std::string *arg3 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int res3 = SWIG_OLDOBJ ; int result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OutputSignalGeneratorFrameGrabber_definePassThroughSignal" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->definePassThroughSignal(arg2,(std::string const &)*arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail:
  if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorFrameGrabber_definePassThroughSignal", 0, 4, argv))) SWIG_fail;
  --argc; if (argc == 3) { int _v = 0; { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_1(self, argc, argv);} 
  check_1: if (argc == 3) {
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 4) {
    PyObject *retobj = _wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_definePassThroughSignal'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal(mvIMPACT::acquire::DigitalOutput *,mvIMPACT::acquire::TDigitalSignal,bool)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal(mvIMPACT::acquire::DigitalOutput *,mvIMPACT::acquire::TDigitalSignal)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal(mvIMPACT::acquire::DigitalOutput *,std::string const &,bool)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal(mvIMPACT::acquire::DigitalOutput *,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_undefineSignal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; int result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorFrameGrabber_undefineSignal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_undefineSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_undefineSignal" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->undefineSignal(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_defineLineScanPulse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  mvIMPACT::acquire::DigitalOutput *arg2 = (mvIMPACT::acquire::DigitalOutput *) 0 ;
  mvIMPACT::acquire::TDeviceSignalOutputStartEvent arg3 ; int arg4 ; int arg5 ; int arg6 ; unsigned int arg7 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; unsigned int val7 ; int ecode7 = 0 ; PyObject *swig_obj[7] ; int result;
  if (!SWIG_Python_UnpackTuple(args, "OutputSignalGeneratorFrameGrabber_defineLineScanPulse", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_defineLineScanPulse" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputSignalGeneratorFrameGrabber_defineLineScanPulse" "', argument " "2"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OutputSignalGeneratorFrameGrabber_defineLineScanPulse" "', argument " "3"" of type '" "mvIMPACT::acquire::TDeviceSignalOutputStartEvent""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OutputSignalGeneratorFrameGrabber_defineLineScanPulse" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "OutputSignalGeneratorFrameGrabber_defineLineScanPulse" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "OutputSignalGeneratorFrameGrabber_defineLineScanPulse" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "OutputSignalGeneratorFrameGrabber_defineLineScanPulse" "', argument " "7"" of type '" "unsigned int""'"); }
    arg7 = static_cast< unsigned int >(val7); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->defineLineScanPulse(arg2,arg3,arg4,arg5,arg6,arg7); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_controlMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDigitalOutputControlMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_controlMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDigitalOutputControlMode *)& ((arg1)->controlMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_pulseStartEvent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIDeviceSignalOutputStartEvent *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_pulseStartEvent_get" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceSignalOutputStartEvent *)& ((arg1)->pulseStartEvent);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_imageTrigger_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *arg1 = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDeviceImageTrigger *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputSignalGeneratorFrameGrabber_imageTrigger_get" "', argument " "1"" of type '" "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceImageTrigger *)& ((arg1)->imageTrigger); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *OutputSignalGeneratorFrameGrabber_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OutputSignalGeneratorFrameGrabber_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Connector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::Connector *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Connector" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Connector" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Connector" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Connector *)new mvIMPACT::acquire::Connector(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Connector, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_Connector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::Connector *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Connector" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::Connector *)new mvIMPACT::acquire::Connector(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Connector, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Connector(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Connector", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_Connector__SWIG_1(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 2) { PyObject *retobj = _wrap_new_Connector__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Connector'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::Connector::Connector(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::Connector::Connector(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_Connector_cameraOutputUsed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Connector *arg1 = (mvIMPACT::acquire::Connector *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraOutput *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Connector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Connector_cameraOutputUsed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Connector *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Connector * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraOutput *)& ((arg1)->cameraOutputUsed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Connector_videoChannel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Connector *arg1 = (mvIMPACT::acquire::Connector *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Connector, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Connector_videoChannel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Connector *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Connector * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->videoChannel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Connector_pinDescription_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Connector *arg1 = (mvIMPACT::acquire::Connector *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Connector, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Connector_pinDescription_get" "', argument " "1"" of type '" "mvIMPACT::acquire::Connector *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Connector * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->pinDescription); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_Connector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Connector *arg1 = (mvIMPACT::acquire::Connector *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Connector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Connector" "', argument " "1"" of type '" "mvIMPACT::acquire::Connector *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Connector * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *Connector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__Connector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Connector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BasicDeviceSettingsWithAOI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::BasicDeviceSettingsWithAOI *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BasicDeviceSettingsWithAOI" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BasicDeviceSettingsWithAOI" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BasicDeviceSettingsWithAOI" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)new mvIMPACT::acquire::BasicDeviceSettingsWithAOI(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_BasicDeviceSettingsWithAOI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::BasicDeviceSettingsWithAOI *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BasicDeviceSettingsWithAOI" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)new mvIMPACT::acquire::BasicDeviceSettingsWithAOI(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_BasicDeviceSettingsWithAOI(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BasicDeviceSettingsWithAOI", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_BasicDeviceSettingsWithAOI__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_BasicDeviceSettingsWithAOI__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BasicDeviceSettingsWithAOI'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::BasicDeviceSettingsWithAOI::BasicDeviceSettingsWithAOI(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::BasicDeviceSettingsWithAOI::BasicDeviceSettingsWithAOI(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_BasicDeviceSettingsWithAOI_aoiHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::BasicDeviceSettingsWithAOI *arg1 = (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicDeviceSettingsWithAOI_aoiHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BasicDeviceSettingsWithAOI *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BasicDeviceSettingsWithAOI * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BasicDeviceSettingsWithAOI_aoiStartX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::BasicDeviceSettingsWithAOI *arg1 = (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicDeviceSettingsWithAOI_aoiStartX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BasicDeviceSettingsWithAOI *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BasicDeviceSettingsWithAOI * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiStartX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BasicDeviceSettingsWithAOI_aoiStartY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::BasicDeviceSettingsWithAOI *arg1 = (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicDeviceSettingsWithAOI_aoiStartY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BasicDeviceSettingsWithAOI *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BasicDeviceSettingsWithAOI * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiStartY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_BasicDeviceSettingsWithAOI_aoiWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::BasicDeviceSettingsWithAOI *arg1 = (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicDeviceSettingsWithAOI_aoiWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::BasicDeviceSettingsWithAOI *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BasicDeviceSettingsWithAOI * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_BasicDeviceSettingsWithAOI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::BasicDeviceSettingsWithAOI *arg1 = (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BasicDeviceSettingsWithAOI" "', argument " "1"" of type '" "mvIMPACT::acquire::BasicDeviceSettingsWithAOI *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::BasicDeviceSettingsWithAOI * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *BasicDeviceSettingsWithAOI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BasicDeviceSettingsWithAOI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CameraSettingsBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::CameraSettingsBase *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsBase" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CameraSettingsBase" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraSettingsBase" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsBase *)new mvIMPACT::acquire::CameraSettingsBase(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBase, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::CameraSettingsBase *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsBase" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsBase *)new mvIMPACT::acquire::CameraSettingsBase(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBase, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsBase(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CameraSettingsBase", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_CameraSettingsBase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_CameraSettingsBase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CameraSettingsBase'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsBase::CameraSettingsBase(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsBase::CameraSettingsBase(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraSettingsBase_pixelFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBase *arg1 = (mvIMPACT::acquire::CameraSettingsBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIImageBufferPixelFormat *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBase, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBase_pixelFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIImageBufferPixelFormat *)& ((arg1)->pixelFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraSettingsBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBase *arg1 = (mvIMPACT::acquire::CameraSettingsBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraSettingsBase" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBase * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraSettingsBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CameraSettingsBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CameraSettingsVirtualDevice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::CameraSettingsVirtualDevice *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsVirtualDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CameraSettingsVirtualDevice" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraSettingsVirtualDevice" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsVirtualDevice *)new mvIMPACT::acquire::CameraSettingsVirtualDevice(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsVirtualDevice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsVirtualDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsVirtualDevice *)new mvIMPACT::acquire::CameraSettingsVirtualDevice(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsVirtualDevice(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CameraSettingsVirtualDevice", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_new_CameraSettingsVirtualDevice__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_CameraSettingsVirtualDevice__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CameraSettingsVirtualDevice'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsVirtualDevice::CameraSettingsVirtualDevice(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsVirtualDevice::CameraSettingsVirtualDevice(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_bufferPartCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_bufferPartCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->bufferPartCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_aoiMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraAoiMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_aoiMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraAoiMode *)& ((arg1)->aoiMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_gain_dB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_gain_dB_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gain_dB); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_testMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIVirtualDeviceTestMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_testMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIVirtualDeviceTestMode *)& ((arg1)->testMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_channelBitDepth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_channelBitDepth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->channelBitDepth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_paddingX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_paddingX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->paddingX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_tapsXGeometry_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraTapsXGeometry *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_tapsXGeometry_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraTapsXGeometry *)& ((arg1)->tapsXGeometry); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_tapsYGeometry_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraTapsYGeometry *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_tapsYGeometry_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraTapsYGeometry *)& ((arg1)->tapsYGeometry); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_frameDelay_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_frameDelay_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->frameDelay_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_imageDirectory_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_imageDirectory_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->imageDirectory); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_imageType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIVirtualDeviceImageType *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_imageType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIVirtualDeviceImageType *)& ((arg1)->imageType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_bayerMosaicParity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBayerMosaicParity *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_bayerMosaicParity_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBayerMosaicParity *)& ((arg1)->bayerMosaicParity); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_testImageBarWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_testImageBarWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->testImageBarWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsVirtualDevice_userData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsVirtualDevice_userData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->userData); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraSettingsVirtualDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsVirtualDevice *arg1 = (mvIMPACT::acquire::CameraSettingsVirtualDevice *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraSettingsVirtualDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsVirtualDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsVirtualDevice * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraSettingsVirtualDevice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CameraSettingsVirtualDevice_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CameraSettingsV4L2Device__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::CameraSettingsV4L2Device *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsV4L2Device" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CameraSettingsV4L2Device" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraSettingsV4L2Device" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsV4L2Device *)new mvIMPACT::acquire::CameraSettingsV4L2Device(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsV4L2Device__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::CameraSettingsV4L2Device *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsV4L2Device" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsV4L2Device *)new mvIMPACT::acquire::CameraSettingsV4L2Device(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsV4L2Device(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_CameraSettingsV4L2Device", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_new_CameraSettingsV4L2Device__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_CameraSettingsV4L2Device__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CameraSettingsV4L2Device'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsV4L2Device::CameraSettingsV4L2Device(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsV4L2Device::CameraSettingsV4L2Device(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_getCustomFeatureIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Component result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_getCustomFeatureIterator" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::CameraSettingsV4L2Device const *)arg1)->getCustomFeatureIterator();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::Component(static_cast< const mvIMPACT::acquire::Component& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_imageWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_imageWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_imageHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_imageHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->imageHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_videoStandard_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_videoStandard_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->videoStandard); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_pixelFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_pixelFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->pixelFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_brightness_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_brightness_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->brightness); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_contrast_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_contrast_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->contrast); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_saturation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->saturation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_hue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->hue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_blackLevel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_blackLevel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->blackLevel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_autoWhiteBalance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_autoWhiteBalance_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->autoWhiteBalance); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_redBalance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_redBalance_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->redBalance); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_blueBalance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_blueBalance_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->blueBalance); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_gamma_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_gamma_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->gamma); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_exposure_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_exposure_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->exposure); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_autoGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_autoGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->autoGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_gain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_gain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->gain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_HFlip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_HFlip_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->HFlip); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_VFlip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_VFlip_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->VFlip); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_powerLineFrequency_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_powerLineFrequency_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->powerLineFrequency); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_hueAuto_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_hueAuto_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->hueAuto); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_whiteBalanceTemperature_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_whiteBalanceTemperature_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->whiteBalanceTemperature); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_sharpness_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_sharpness_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->sharpness); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsV4L2Device_backlightCompensation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsV4L2Device_backlightCompensation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->backlightCompensation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraSettingsV4L2Device(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsV4L2Device *arg1 = (mvIMPACT::acquire::CameraSettingsV4L2Device *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraSettingsV4L2Device" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsV4L2Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsV4L2Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraSettingsV4L2Device_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CameraSettingsV4L2Device_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_AutoControlParameters_getIsAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_getIsAvailable" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::AutoControlParameters const *)arg1)->isAvailable(); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_aoiHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_aoiHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_aoiStartX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_aoiStartX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiStartX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_aoiStartY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_aoiStartY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiStartY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_aoiWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_aoiWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_aoiMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAoiMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_aoiMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAoiMode *)& ((arg1)->aoiMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_desiredAverageGreyValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_desiredAverageGreyValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->desiredAverageGreyValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_controllerSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAutoControlSpeed *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_controllerSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAutoControlSpeed *)& ((arg1)->controllerSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_controllerGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_controllerGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->controllerGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_controllerIntegralTime_ms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_controllerIntegralTime_ms_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->controllerIntegralTime_ms); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_controllerDerivativeTime_ms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_controllerDerivativeTime_ms_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->controllerDerivativeTime_ms); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_controllerDelay_Images_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_controllerDelay_Images_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->controllerDelay_Images); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_gainLowerLimit_dB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_gainLowerLimit_dB_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gainLowerLimit_dB); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_gainUpperLimit_dB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_gainUpperLimit_dB_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gainUpperLimit_dB); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_exposeLowerLimit_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_exposeLowerLimit_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->exposeLowerLimit_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AutoControlParameters_exposeUpperLimit_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoControlParameters_exposeUpperLimit_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->exposeUpperLimit_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_AutoControlParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::AutoControlParameters *arg1 = (mvIMPACT::acquire::AutoControlParameters *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AutoControlParameters" "', argument " "1"" of type '" "mvIMPACT::acquire::AutoControlParameters *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::AutoControlParameters * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *AutoControlParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CameraSettingsBlueDevice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::CameraSettingsBlueDevice *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsBlueDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CameraSettingsBlueDevice" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraSettingsBlueDevice" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsBlueDevice *)new mvIMPACT::acquire::CameraSettingsBlueDevice(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsBlueDevice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::CameraSettingsBlueDevice *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsBlueDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsBlueDevice *)new mvIMPACT::acquire::CameraSettingsBlueDevice(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsBlueDevice(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_CameraSettingsBlueDevice", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_new_CameraSettingsBlueDevice__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_CameraSettingsBlueDevice__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CameraSettingsBlueDevice'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsBlueDevice::CameraSettingsBlueDevice(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsBlueDevice::CameraSettingsBlueDevice(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_autoControlMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAutoControlMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_autoControlMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAutoControlMode *)& ((arg1)->autoControlMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_autoGainControl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAutoGainControl *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_autoGainControl_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAutoGainControl *)& ((arg1)->autoGainControl); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_autoExposeControl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAutoExposureControl *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_autoExposeControl_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAutoExposureControl *)& ((arg1)->autoExposeControl); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_gain_dB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_gain_dB_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gain_dB); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_offset_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_offset_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->offset_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_pixelClock_KHz_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraPixelClock *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_pixelClock_KHz_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraPixelClock *)& ((arg1)->pixelClock_KHz); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_exposeMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraExposeMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_exposeMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraExposeMode *)& ((arg1)->exposeMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_expose_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_expose_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->expose_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_binningMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraBinningMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_binningMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraBinningMode *)& ((arg1)->binningMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_testMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraTestMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_testMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraTestMode *)& ((arg1)->testMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_triggerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraTriggerMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_triggerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraTriggerMode *)& ((arg1)->triggerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_frameDelay_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_frameDelay_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->frameDelay_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_autoControlParameters_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::AutoControlParameters *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_autoControlParameters_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::AutoControlParameters *)& ((arg1)->autoControlParameters); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueDevice_getAutoControlParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::AutoControlParameters *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueDevice_getAutoControlParameters" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::AutoControlParameters *) &(arg1)->getAutoControlParameters();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraSettingsBlueDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueDevice *arg1 = (mvIMPACT::acquire::CameraSettingsBlueDevice *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraSettingsBlueDevice" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueDevice *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueDevice * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraSettingsBlueDevice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CameraSettingsBlueDevice_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_HDRKneePoint_HDRControlVoltage_mV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HDRKneePoint *arg1 = (mvIMPACT::acquire::HDRKneePoint *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__HDRKneePoint, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HDRKneePoint_HDRControlVoltage_mV_get" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRKneePoint *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRKneePoint * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->HDRControlVoltage_mV); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_HDRKneePoint_HDRExposure_ppm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HDRKneePoint *arg1 = (mvIMPACT::acquire::HDRKneePoint *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__HDRKneePoint, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HDRKneePoint_HDRExposure_ppm_get" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRKneePoint *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRKneePoint * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->HDRExposure_ppm); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_HDRKneePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::HDRKneePoint *arg1 = (mvIMPACT::acquire::HDRKneePoint *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__HDRKneePoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HDRKneePoint" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRKneePoint *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRKneePoint * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *HDRKneePoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__HDRKneePoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HDRControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::HDRControl *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::HDRControl *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__HDRControl,  0  | 0); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HDRControl" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRControl const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HDRControl" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRControl const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HDRControl *)new mvIMPACT::acquire::HDRControl((mvIMPACT::acquire::HDRControl const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__HDRControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_HDRControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::HDRControl *arg1 = (mvIMPACT::acquire::HDRControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__HDRControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HDRControl" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_HDRControl_getIsAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::HDRControl *arg1 = (mvIMPACT::acquire::HDRControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__HDRControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HDRControl_getIsAvailable" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::HDRControl const *)arg1)->isAvailable(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_HDRControl_getHDRKneePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::HDRControl *arg1 = (mvIMPACT::acquire::HDRControl *) 0 ; unsigned int arg2 ; void *argp1 = 0 ;
  int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::HDRKneePoint *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "HDRControl_getHDRKneePoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__HDRControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HDRControl_getHDRKneePoint" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRControl * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HDRControl_getHDRKneePoint" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HDRKneePoint *) &((mvIMPACT::acquire::HDRControl const *)arg1)->getHDRKneePoint(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__HDRKneePoint, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_HDRControl_HDREnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::HDRControl *arg1 = (mvIMPACT::acquire::HDRControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__HDRControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HDRControl_HDREnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->HDREnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_HDRControl_HDRMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::HDRControl *arg1 = (mvIMPACT::acquire::HDRControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraHDRMode *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__HDRControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HDRControl_HDRMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraHDRMode *)& ((arg1)->HDRMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_HDRControl_HDRKneePointCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HDRControl *arg1 = (mvIMPACT::acquire::HDRControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__HDRControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HDRControl_HDRKneePointCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::HDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::HDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->HDRKneePointCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *HDRControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__HDRControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HDRControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CameraSettingsBlueFOX__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::CameraSettingsBlueFOX *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CameraSettingsBlueFOX" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraSettingsBlueFOX" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsBlueFOX *)new mvIMPACT::acquire::CameraSettingsBlueFOX(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsBlueFOX__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::CameraSettingsBlueFOX *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsBlueFOX *)new mvIMPACT::acquire::CameraSettingsBlueFOX(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsBlueFOX(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_CameraSettingsBlueFOX", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_CameraSettingsBlueFOX__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_CameraSettingsBlueFOX__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CameraSettingsBlueFOX'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsBlueFOX::CameraSettingsBlueFOX(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsBlueFOX::CameraSettingsBlueFOX(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_getHDRControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::HDRControl *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_getHDRControl" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HDRControl *) &(arg1)->getHDRControl(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__HDRControl, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_offsetAutoCalibration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAutoOffsetCalibration *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_offsetAutoCalibration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAutoOffsetCalibration *)& ((arg1)->offsetAutoCalibration);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_offsetCorrection_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_offsetCorrection_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->offsetCorrection_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_offsetAutoBlackLevel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_offsetAutoBlackLevel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->offsetAutoBlackLevel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_offsetAutoBlackSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBlueFOXOffsetAutoBlackSpeed *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_offsetAutoBlackSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBlueFOXOffsetAutoBlackSpeed *)& ((arg1)->offsetAutoBlackSpeed);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_lineDelay_clk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_lineDelay_clk_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->lineDelay_clk); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_advancedOptions_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDeviceAdvancedOptions *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_advancedOptions_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceAdvancedOptions *)& ((arg1)->advancedOptions); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_flashToExposeDelay_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_flashToExposeDelay_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->flashToExposeDelay_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_flashMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraFlashMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_flashMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraFlashMode *)& ((arg1)->flashMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_flashType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraFlashType *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_flashType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraFlashType *)& ((arg1)->flashType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_shutterMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraShutterMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_shutterMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraShutterMode *)& ((arg1)->shutterMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_triggerSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraTriggerSource *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_triggerSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraTriggerSource *)& ((arg1)->triggerSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueFOX_sensorTimingMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBlueFOXSensorTiming *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueFOX_sensorTimingMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBlueFOXSensorTiming *)& ((arg1)->sensorTimingMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraSettingsBlueFOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraSettingsBlueFOX *arg1 = (mvIMPACT::acquire::CameraSettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraSettingsBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueFOX * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraSettingsBlueFOX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CameraSettingsBlueFOX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CameraSettingsBlueCOUGAR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::CameraSettingsBlueCOUGAR *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsBlueCOUGAR" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CameraSettingsBlueCOUGAR" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraSettingsBlueCOUGAR" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *)new mvIMPACT::acquire::CameraSettingsBlueCOUGAR(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsBlueCOUGAR__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsBlueCOUGAR" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *)new mvIMPACT::acquire::CameraSettingsBlueCOUGAR(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsBlueCOUGAR(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_CameraSettingsBlueCOUGAR", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_new_CameraSettingsBlueCOUGAR__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_CameraSettingsBlueCOUGAR__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CameraSettingsBlueCOUGAR'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsBlueCOUGAR::CameraSettingsBlueCOUGAR(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsBlueCOUGAR::CameraSettingsBlueCOUGAR(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_CameraSettingsBlueCOUGAR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraSettingsBlueCOUGAR" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_getTriggerControlCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueCOUGAR_getTriggerControlCount" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *)arg1)->getTriggerControlCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_triggerControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TriggerControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueCOUGAR_triggerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraSettingsBlueCOUGAR_triggerControl" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TriggerControl *)((mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *)arg1)->triggerControl(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_triggerControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::TriggerControl *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueCOUGAR_triggerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraSettingsBlueCOUGAR_triggerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CameraSettingsBlueCOUGAR_triggerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TriggerControl *)((mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *)arg1)->triggerControl((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_triggerControl(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CameraSettingsBlueCOUGAR_triggerControl", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_CameraSettingsBlueCOUGAR_triggerControl__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 2) { PyObject *retobj = _wrap_CameraSettingsBlueCOUGAR_triggerControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CameraSettingsBlueCOUGAR_triggerControl'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::CameraSettingsBlueCOUGAR::triggerControl(unsigned int) const\n"
  "    mvIMPACT::acquire::CameraSettingsBlueCOUGAR::triggerControl(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_getHDRControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::HDRControl *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueCOUGAR_getHDRControl" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::HDRControl *) &(arg1)->getHDRControl(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__HDRControl, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_frameRate_Hz_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueCOUGAR_frameRate_Hz_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->frameRate_Hz); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_partialScanMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueCOUGAR_partialScanMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->partialScanMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_triggerInterface_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDeviceTriggerInterface *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueCOUGAR_triggerInterface_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceTriggerInterface *)& ((arg1)->triggerInterface); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_triggerSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraTriggerSource *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueCOUGAR_triggerSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraTriggerSource *)& ((arg1)->triggerSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsBlueCOUGAR_acquisitionBurstFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsBlueCOUGAR *arg1 = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsBlueCOUGAR_acquisitionBurstFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->acquisitionBurstFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraSettingsBlueCOUGAR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CameraSettingsBlueCOUGAR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CameraSettingsFrameGrabber__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::CameraSettingsFrameGrabber *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CameraSettingsFrameGrabber" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraSettingsFrameGrabber" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsFrameGrabber *)new mvIMPACT::acquire::CameraSettingsFrameGrabber(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsFrameGrabber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraSettingsFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraSettingsFrameGrabber *)new mvIMPACT::acquire::CameraSettingsFrameGrabber(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraSettingsFrameGrabber(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CameraSettingsFrameGrabber", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_CameraSettingsFrameGrabber__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_CameraSettingsFrameGrabber__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CameraSettingsFrameGrabber'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsFrameGrabber::CameraSettingsFrameGrabber(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsFrameGrabber::CameraSettingsFrameGrabber(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_CameraSettingsFrameGrabber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraSettingsFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_getTriggerControlCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_getTriggerControlCount" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::CameraSettingsFrameGrabber const *)arg1)->getTriggerControlCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_triggerControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ;
  unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TriggerControl *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_triggerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraSettingsFrameGrabber_triggerControl" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TriggerControl *)((mvIMPACT::acquire::CameraSettingsFrameGrabber const *)arg1)->triggerControl(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_triggerControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::TriggerControl *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_triggerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraSettingsFrameGrabber_triggerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CameraSettingsFrameGrabber_triggerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TriggerControl *)((mvIMPACT::acquire::CameraSettingsFrameGrabber const *)arg1)->triggerControl((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__TriggerControl, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_triggerControl(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CameraSettingsFrameGrabber_triggerControl", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_CameraSettingsFrameGrabber_triggerControl__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 2) { PyObject *retobj = _wrap_CameraSettingsFrameGrabber_triggerControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CameraSettingsFrameGrabber_triggerControl'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::CameraSettingsFrameGrabber::triggerControl(unsigned int) const\n"
  "    mvIMPACT::acquire::CameraSettingsFrameGrabber::triggerControl(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_type_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->type); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_aoiMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraAoiMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_aoiMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraAoiMode *)& ((arg1)->aoiMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_gain_dB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_gain_dB_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gain_dB); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_offset_mV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_offset_mV_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->offset_mV); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_scanClock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIScanClock *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_scanClock_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIScanClock *)& ((arg1)->scanClock); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_triggerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDeviceTriggerMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_triggerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceTriggerMode *)& ((arg1)->triggerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_softwareTriggerPeriod_ms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_softwareTriggerPeriod_ms_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->softwareTriggerPeriod_ms); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_serialPortBaudrate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraSerialPortBaudRate *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_serialPortBaudrate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraSerialPortBaudRate *)& ((arg1)->serialPortBaudrate);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_interlacedMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIInterlacedMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_interlacedMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIInterlacedMode *)& ((arg1)->interlacedMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_acquisitionField_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAcquisitionField *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_acquisitionField_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAcquisitionField *)& ((arg1)->acquisitionField); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_scanRateMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDeviceScanRateMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_scanRateMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDeviceScanRateMode *)& ((arg1)->scanRateMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_scanRate_kHz_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_scanRate_kHz_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->scanRate_kHz); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_luminance_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_luminance_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->luminance_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_saturation_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_saturation_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->saturation_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_hue_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_hue_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->hue_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_contrast_pc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_contrast_pc_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->contrast_pc); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraSettingsFrameGrabber_lineCounter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraSettingsFrameGrabber *arg1 = (mvIMPACT::acquire::CameraSettingsFrameGrabber *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyILineCounter *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraSettingsFrameGrabber_lineCounter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraSettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraSettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyILineCounter *)& ((arg1)->lineCounter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraSettingsFrameGrabber_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CameraSettingsFrameGrabber_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CameraDescriptionBase_getClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_getClassName" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::CameraDescriptionBase const *)arg1)->getClassName(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_copyDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ; int result;
  if (!SWIG_Python_UnpackTuple(args, "CameraDescriptionBase_copyDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_copyDescription" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraDescriptionBase_copyDescription" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CameraDescriptionBase_copyDescription" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::CameraDescriptionBase const *)arg1)->copyDescription((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_exportDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_exportDescription" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::CameraDescriptionBase const *)arg1)->exportDescription();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_importDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_importDescription" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::CameraDescriptionBase const *)arg1)->importDescription();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_name_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->name); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_videoOutput_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraOutput *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_videoOutput_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraOutput *)& ((arg1)->videoOutput); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_interlacedType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraInterlacedType *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_interlacedType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraInterlacedType *)& ((arg1)->interlacedType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_aoiHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_aoiHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_aoiStartX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_aoiStartX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiStartX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_aoiStartY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_aoiStartY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiStartY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionBase_aoiWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionBase_aoiWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->aoiWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraDescriptionBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionBase *arg1 = (mvIMPACT::acquire::CameraDescriptionBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionBase" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionBase * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_CameraDescriptionDigitalBase_bitsPerPixel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigitalBase *arg1 = (mvIMPACT::acquire::CameraDescriptionDigitalBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionDigitalBase_bitsPerPixel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigitalBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigitalBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->bitsPerPixel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionDigitalBase_format_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigitalBase *arg1 = (mvIMPACT::acquire::CameraDescriptionDigitalBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraDataFormat *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionDigitalBase_format_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigitalBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigitalBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraDataFormat *)& ((arg1)->format); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionDigitalBase_bayerParity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigitalBase *arg1 = (mvIMPACT::acquire::CameraDescriptionDigitalBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBayerMosaicParity *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionDigitalBase_bayerParity_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigitalBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigitalBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBayerMosaicParity *)& ((arg1)->bayerParity); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraDescriptionDigitalBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigitalBase *arg1 = (mvIMPACT::acquire::CameraDescriptionDigitalBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionDigitalBase" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigitalBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigitalBase * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionDigitalBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_CameraDescriptionSDI_videoStandard_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionSDI *arg1 = (mvIMPACT::acquire::CameraDescriptionSDI *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIVideoStandard *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionSDI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionSDI_videoStandard_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionSDI *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionSDI * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIVideoStandard *)& ((arg1)->videoStandard); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraDescriptionSDI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionSDI *arg1 = (mvIMPACT::acquire::CameraDescriptionSDI *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionSDI, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionSDI" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionSDI *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionSDI * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionSDI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionSDI, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_CameraDescriptionDigitalBase2_pixelsPerCycle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigitalBase2 *arg1 = (mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionDigitalBase2_pixelsPerCycle_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigitalBase2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigitalBase2 * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->pixelsPerCycle); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionDigitalBase2_scanMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigitalBase2 *arg1 = (mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraScanMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionDigitalBase2_scanMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigitalBase2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigitalBase2 * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraScanMode *)& ((arg1)->scanMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraDescriptionDigitalBase2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigitalBase2 *arg1 = (mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionDigitalBase2" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigitalBase2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigitalBase2 * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionDigitalBase2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_CameraDescriptionCameraLink_dataValid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionCameraLink *arg1 = (mvIMPACT::acquire::CameraDescriptionCameraLink *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraLinkDataValidMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionCameraLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionCameraLink_dataValid_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionCameraLink *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionCameraLink * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraLinkDataValidMode *)& ((arg1)->dataValid); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionCameraLink_tapsXGeometry_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionCameraLink *arg1 = (mvIMPACT::acquire::CameraDescriptionCameraLink *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraTapsXGeometry *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionCameraLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionCameraLink_tapsXGeometry_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionCameraLink *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionCameraLink * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraTapsXGeometry *)& ((arg1)->tapsXGeometry); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionCameraLink_tapsYGeometry_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionCameraLink *arg1 = (mvIMPACT::acquire::CameraDescriptionCameraLink *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraTapsYGeometry *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionCameraLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionCameraLink_tapsYGeometry_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionCameraLink *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionCameraLink * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraTapsYGeometry *)& ((arg1)->tapsYGeometry); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraDescriptionCameraLink(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionCameraLink *arg1 = (mvIMPACT::acquire::CameraDescriptionCameraLink *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionCameraLink, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionCameraLink" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionCameraLink *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionCameraLink * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionCameraLink_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionCameraLink, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_CameraDescriptionDigital_frameSync_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigital *arg1 = (mvIMPACT::acquire::CameraDescriptionDigital *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraExternalSyncEdge *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigital, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionDigital_frameSync_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigital *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigital * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraExternalSyncEdge *)& ((arg1)->frameSync); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionDigital_lineSync_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigital *arg1 = (mvIMPACT::acquire::CameraDescriptionDigital *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraExternalSyncEdge *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigital, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionDigital_lineSync_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigital *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigital * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraExternalSyncEdge *)& ((arg1)->lineSync); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionDigital_pixelClk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigital *arg1 = (mvIMPACT::acquire::CameraDescriptionDigital *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraExternalSyncEdge *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigital, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionDigital_pixelClk_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigital *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigital * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraExternalSyncEdge *)& ((arg1)->pixelClk); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraDescriptionDigital(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionDigital *arg1 = (mvIMPACT::acquire::CameraDescriptionDigital *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigital, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionDigital" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionDigital *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionDigital * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionDigital_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigital, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_CameraDescriptionStandardBase_videoStandard_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionStandardBase *arg1 = (mvIMPACT::acquire::CameraDescriptionStandardBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIVideoStandard *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandardBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionStandardBase_videoStandard_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionStandardBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionStandardBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIVideoStandard *)& ((arg1)->videoStandard); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionStandardBase_scanStandard_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionStandardBase *arg1 = (mvIMPACT::acquire::CameraDescriptionStandardBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIScanStandard *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandardBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionStandardBase_scanStandard_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionStandardBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionStandardBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIScanStandard *)& ((arg1)->scanStandard); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionStandardBase_scanRate_kHz_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionStandardBase *arg1 = (mvIMPACT::acquire::CameraDescriptionStandardBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandardBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionStandardBase_scanRate_kHz_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionStandardBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionStandardBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->scanRate_kHz); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionStandardBase_startField_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionStandardBase *arg1 = (mvIMPACT::acquire::CameraDescriptionStandardBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIAcquisitionField *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandardBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionStandardBase_startField_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionStandardBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionStandardBase * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIAcquisitionField *)& ((arg1)->startField); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraDescriptionStandardBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionStandardBase *arg1 = (mvIMPACT::acquire::CameraDescriptionStandardBase *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandardBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionStandardBase" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionStandardBase *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionStandardBase * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionStandardBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandardBase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_CameraDescriptionStandard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionStandard *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandard, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionStandard * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionStandard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandard, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_lineFrequency_Hz_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_lineFrequency_Hz_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->lineFrequency_Hz); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_VDOutput_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraExternalSyncEdge *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_VDOutput_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraExternalSyncEdge *)& ((arg1)->VDOutput); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_HDOutput_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraExternalSyncEdge *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_HDOutput_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraExternalSyncEdge *)& ((arg1)->HDOutput); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_syncOutput_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraExternalSyncOutput *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_syncOutput_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraExternalSyncOutput *)& ((arg1)->syncOutput); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_pixelClockOutput_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyICameraExternalSyncEdge *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_pixelClockOutput_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyICameraExternalSyncEdge *)& ((arg1)->pixelClockOutput); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_fieldGateMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIFieldGateMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_fieldGateMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIFieldGateMode *)& ((arg1)->fieldGateMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_fieldGateStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_fieldGateStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->fieldGateStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_fieldGateWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_fieldGateWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->fieldGateWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_clampMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIClampMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_clampMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIClampMode *)& ((arg1)->clampMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionNonStandard_clampStart_us_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionNonStandard_clampStart_us_get" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->clampStart_us); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CameraDescriptionNonStandard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionNonStandard *arg1 = (mvIMPACT::acquire::CameraDescriptionNonStandard *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionNonStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionNonStandard *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionNonStandard * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionNonStandard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CameraDescriptionManager__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::CameraDescriptionManager *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraDescriptionManager" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionManager *)new mvIMPACT::acquire::CameraDescriptionManager(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraDescriptionManager__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::CameraDescriptionManager *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::CameraDescriptionManager *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CameraDescriptionManager" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CameraDescriptionManager" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionManager *)new mvIMPACT::acquire::CameraDescriptionManager((mvIMPACT::acquire::CameraDescriptionManager const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CameraDescriptionManager(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_CameraDescriptionManager", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 1) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Device, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_1; return _wrap_new_CameraDescriptionManager__SWIG_0(self, argc, argv);}  check_1: if (argc == 1) {
    PyObject *retobj = _wrap_new_CameraDescriptionManager__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CameraDescriptionManager'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::CameraDescriptionManager(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::CameraDescriptionManager(mvIMPACT::acquire::CameraDescriptionManager const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_CameraDescriptionManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraDescriptionManager" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_getCLCameraDescriptionCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_getCLCameraDescriptionCount" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getCLCameraDescriptionCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionCameraLink__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::CameraDescriptionCameraLink *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionCameraLink" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraDescriptionManager_cameraDescriptionCameraLink" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionCameraLink *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionCameraLink(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionCameraLink, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionCameraLink__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::CameraDescriptionCameraLink *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionCameraLink" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraDescriptionManager_cameraDescriptionCameraLink" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CameraDescriptionManager_cameraDescriptionCameraLink" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionCameraLink *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionCameraLink((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionCameraLink, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionCameraLink(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CameraDescriptionManager_cameraDescriptionCameraLink", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_CameraDescriptionManager_cameraDescriptionCameraLink__SWIG_0(self, argc, argv);} 
  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_CameraDescriptionManager_cameraDescriptionCameraLink__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionCameraLink'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionCameraLink(unsigned int) const\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionCameraLink(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_getSDICameraDescriptionCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_getSDICameraDescriptionCount" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getSDICameraDescriptionCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionSDI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::CameraDescriptionSDI *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionSDI" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraDescriptionManager_cameraDescriptionSDI" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionSDI *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionSDI(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionSDI, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionSDI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::CameraDescriptionSDI *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionSDI" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraDescriptionManager_cameraDescriptionSDI" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CameraDescriptionManager_cameraDescriptionSDI" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionSDI *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionSDI((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionSDI, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionSDI(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CameraDescriptionManager_cameraDescriptionSDI", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_CameraDescriptionManager_cameraDescriptionSDI__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 2) { PyObject *retobj = _wrap_CameraDescriptionManager_cameraDescriptionSDI__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionSDI'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionSDI(unsigned int) const\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionSDI(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_getDigitalCameraDescriptionCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_getDigitalCameraDescriptionCount" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getDigitalCameraDescriptionCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionDigital__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::CameraDescriptionDigital *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionDigital" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraDescriptionManager_cameraDescriptionDigital" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionDigital *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionDigital(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigital, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionDigital__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::CameraDescriptionDigital *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionDigital" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraDescriptionManager_cameraDescriptionDigital" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CameraDescriptionManager_cameraDescriptionDigital" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionDigital *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionDigital((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigital, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionDigital(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CameraDescriptionManager_cameraDescriptionDigital", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_CameraDescriptionManager_cameraDescriptionDigital__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 2) { PyObject *retobj = _wrap_CameraDescriptionManager_cameraDescriptionDigital__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionDigital'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionDigital(unsigned int) const\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionDigital(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_getStandardCameraDescriptionCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_getStandardCameraDescriptionCount" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getStandardCameraDescriptionCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionStandard__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::CameraDescriptionStandard *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraDescriptionManager_cameraDescriptionStandard" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionStandard *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionStandard(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandard, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionStandard__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::CameraDescriptionStandard *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraDescriptionManager_cameraDescriptionStandard" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CameraDescriptionManager_cameraDescriptionStandard" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionStandard *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionStandard((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandard, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionStandard(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CameraDescriptionManager_cameraDescriptionStandard", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_CameraDescriptionManager_cameraDescriptionStandard__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 2) { PyObject *retobj = _wrap_CameraDescriptionManager_cameraDescriptionStandard__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionStandard'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionStandard(unsigned int) const\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionStandard(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_getNonStandardCameraDescriptionCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_getNonStandardCameraDescriptionCount" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getNonStandardCameraDescriptionCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionNonStandard__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; unsigned int arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::CameraDescriptionNonStandard *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionNonStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraDescriptionManager_cameraDescriptionNonStandard" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionNonStandard *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionNonStandard(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionNonStandard__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::CameraDescriptionNonStandard *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_cameraDescriptionNonStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraDescriptionManager_cameraDescriptionNonStandard" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CameraDescriptionManager_cameraDescriptionNonStandard" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::CameraDescriptionNonStandard *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionNonStandard((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_cameraDescriptionNonStandard(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CameraDescriptionManager_cameraDescriptionNonStandard", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_CameraDescriptionManager_cameraDescriptionNonStandard__SWIG_0(self, argc, argv);} 
  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_CameraDescriptionManager_cameraDescriptionNonStandard__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionNonStandard'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionNonStandard(unsigned int) const\n"
  "    mvIMPACT::acquire::CameraDescriptionManager::cameraDescriptionNonStandard(std::string const &) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_CameraDescriptionManager_getTotalCameraDescriptionCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::CameraDescriptionManager *arg1 = (mvIMPACT::acquire::CameraDescriptionManager *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraDescriptionManager_getTotalCameraDescriptionCount" "', argument " "1"" of type '" "mvIMPACT::acquire::CameraDescriptionManager const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::CameraDescriptionManager * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getTotalCameraDescriptionCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraDescriptionManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CameraDescriptionManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_I2CControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::I2CControl *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_I2CControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::I2CControl *)new mvIMPACT::acquire::I2CControl(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__I2CControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2COperationMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyII2COperationMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2COperationMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyII2COperationMode *)& ((arg1)->I2COperationMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2COperationExecute_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2COperationExecute_get" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->I2COperationExecute); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2COperationStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyII2COperationStatus *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2COperationStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyII2COperationStatus *)& ((arg1)->I2COperationStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2CDeviceAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2CDeviceAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->I2CDeviceAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2CDeviceSubAddressWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2CDeviceSubAddressWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->I2CDeviceSubAddressWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2CDeviceSubAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2CDeviceSubAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->I2CDeviceSubAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2CBuffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2CBuffer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->I2CBuffer); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2CBufferLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2CBufferLength_get" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->I2CBufferLength); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2CRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ;
  void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; PyObject *swig_obj[5] ; std::string result;
  if (!SWIG_Python_UnpackTuple(args, "I2CControl_I2CRead", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2CRead" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "I2CControl_I2CRead" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "I2CControl_I2CRead" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "I2CControl_I2CRead" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "I2CControl_I2CRead" "', argument " "5"" of type '" "int""'"); }  
  arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (arg1)->I2CRead(arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_I2CControl_I2CWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; int arg2 ; int arg3 ; int arg4 ;
  std::string *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ;
  int ecode4 = 0 ; int res5 = SWIG_OLDOBJ ; PyObject *swig_obj[5] ;
  if (!SWIG_Python_UnpackTuple(args, "I2CControl_I2CWrite", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "I2CControl_I2CWrite" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "I2CControl_I2CWrite" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "I2CControl_I2CWrite" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "I2CControl_I2CWrite" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { std::string *ptr = (std::string *)0; res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "I2CControl_I2CWrite" "', argument " "5"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "I2CControl_I2CWrite" "', argument " "5"" of type '" "std::string const &""'"); }
     arg5 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->I2CWrite(arg2,arg3,arg4,(std::string const &)*arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res5)) delete arg5; return resultobj; fail: if (SWIG_IsNewObj(res5)) delete arg5; return NULL; }
SWIGINTERN PyObject *_wrap_delete_I2CControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::I2CControl *arg1 = (mvIMPACT::acquire::I2CControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__I2CControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_I2CControl" "', argument " "1"" of type '" "mvIMPACT::acquire::I2CControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::I2CControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *I2CControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__I2CControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *I2CControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MotorFocusControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::MotorFocusControl *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MotorFocusControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::MotorFocusControl *)new mvIMPACT::acquire::MotorFocusControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_MotorFocusControl_motorFocusSendBuffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MotorFocusControl_motorFocusSendBuffer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->motorFocusSendBuffer); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_MotorFocusControl_motorFocusReceiveBuffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MotorFocusControl_motorFocusReceiveBuffer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->motorFocusReceiveBuffer); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_MotorFocusControl_motorFocusSend_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MotorFocusControl_motorFocusSend_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->motorFocusSend); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_MotorFocusControl_motorFocusIncrement_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MotorFocusControl_motorFocusIncrement_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->motorFocusIncrement); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_MotorFocusControl_motorFocusNear_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MotorFocusControl_motorFocusNear_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->motorFocusNear); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_MotorFocusControl_motorFocusFar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MotorFocusControl_motorFocusFar_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->motorFocusFar); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_MotorFocusControl_motorFocusAbsolutePositionCurrent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MotorFocusControl_motorFocusAbsolutePositionCurrent_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->motorFocusAbsolutePositionCurrent); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_MotorFocusControl_motorFocusAbsolutePositionDesired_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MotorFocusControl_motorFocusAbsolutePositionDesired_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->motorFocusAbsolutePositionDesired); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_MotorFocusControl_motorFocusMoveToAbsolutePositionDesired_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MotorFocusControl_motorFocusMoveToAbsolutePositionDesired_get" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->motorFocusMoveToAbsolutePositionDesired); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_MotorFocusControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::MotorFocusControl *arg1 = (mvIMPACT::acquire::MotorFocusControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MotorFocusControl" "', argument " "1"" of type '" "mvIMPACT::acquire::MotorFocusControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::MotorFocusControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *MotorFocusControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MotorFocusControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DigitalIOMeasurementControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::DigitalIOMeasurementControl *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DigitalIOMeasurementControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::DigitalIOMeasurementControl *)new mvIMPACT::acquire::DigitalIOMeasurementControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__DigitalIOMeasurementControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOMeasurementControl_digitalIOMeasurementMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalIOMeasurementControl *arg1 = (mvIMPACT::acquire::DigitalIOMeasurementControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDigitalIOMeasurementMode *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalIOMeasurementControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOMeasurementControl_digitalIOMeasurementMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalIOMeasurementControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalIOMeasurementControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDigitalIOMeasurementMode *)& ((arg1)->digitalIOMeasurementMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOMeasurementControl_digitalIOMeasurementSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalIOMeasurementControl *arg1 = (mvIMPACT::acquire::DigitalIOMeasurementControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDigitalIOMeasurementSource *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalIOMeasurementControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOMeasurementControl_digitalIOMeasurementSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalIOMeasurementControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalIOMeasurementControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDigitalIOMeasurementSource *)& ((arg1)->digitalIOMeasurementSource);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOMeasurementControl_digitalIOMeasurementResult_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalIOMeasurementControl *arg1 = (mvIMPACT::acquire::DigitalIOMeasurementControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalIOMeasurementControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOMeasurementControl_digitalIOMeasurementResult_get" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalIOMeasurementControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalIOMeasurementControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->digitalIOMeasurementResult); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_DigitalIOMeasurementControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::DigitalIOMeasurementControl *arg1 = (mvIMPACT::acquire::DigitalIOMeasurementControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__DigitalIOMeasurementControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DigitalIOMeasurementControl" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalIOMeasurementControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalIOMeasurementControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *DigitalIOMeasurementControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__DigitalIOMeasurementControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DigitalIOMeasurementControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SettingsBlueFOX__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::SettingsBlueFOX *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettingsBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SettingsBlueFOX" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettingsBlueFOX" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::SettingsBlueFOX *)new mvIMPACT::acquire::SettingsBlueFOX(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__SettingsBlueFOX, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_SettingsBlueFOX__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::SettingsBlueFOX *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettingsBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::SettingsBlueFOX *)new mvIMPACT::acquire::SettingsBlueFOX(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__SettingsBlueFOX, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_SettingsBlueFOX(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SettingsBlueFOX", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_SettingsBlueFOX__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_SettingsBlueFOX__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SettingsBlueFOX'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::SettingsBlueFOX::SettingsBlueFOX(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::SettingsBlueFOX::SettingsBlueFOX(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_SettingsBlueFOX_cameraSetting_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SettingsBlueFOX *arg1 = (mvIMPACT::acquire::SettingsBlueFOX *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::CameraSettingsBlueFOX *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SettingsBlueFOX, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SettingsBlueFOX_cameraSetting_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SettingsBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::CameraSettingsBlueFOX *)& ((arg1)->cameraSetting); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SettingsBlueFOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SettingsBlueFOX *arg1 = (mvIMPACT::acquire::SettingsBlueFOX *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SettingsBlueFOX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettingsBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::SettingsBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SettingsBlueFOX * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SettingsBlueFOX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__SettingsBlueFOX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SettingsBlueFOX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SettingsFrameGrabber__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::SettingsFrameGrabber *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettingsFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SettingsFrameGrabber" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettingsFrameGrabber" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::SettingsFrameGrabber *)new mvIMPACT::acquire::SettingsFrameGrabber(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__SettingsFrameGrabber, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_SettingsFrameGrabber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::SettingsFrameGrabber *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettingsFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::SettingsFrameGrabber *)new mvIMPACT::acquire::SettingsFrameGrabber(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__SettingsFrameGrabber, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_SettingsFrameGrabber(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_SettingsFrameGrabber", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_SettingsFrameGrabber__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_SettingsFrameGrabber__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SettingsFrameGrabber'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::SettingsFrameGrabber::SettingsFrameGrabber(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::SettingsFrameGrabber::SettingsFrameGrabber(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_SettingsFrameGrabber_cameraSetting_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SettingsFrameGrabber *arg1 = (mvIMPACT::acquire::SettingsFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::CameraSettingsFrameGrabber *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SettingsFrameGrabber_cameraSetting_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::CameraSettingsFrameGrabber *)& ((arg1)->cameraSetting); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SettingsFrameGrabber_connector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SettingsFrameGrabber *arg1 = (mvIMPACT::acquire::SettingsFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Connector *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SettingsFrameGrabber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SettingsFrameGrabber_connector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SettingsFrameGrabber * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Connector *)& ((arg1)->connector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Connector, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SettingsFrameGrabber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SettingsFrameGrabber *arg1 = (mvIMPACT::acquire::SettingsFrameGrabber *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SettingsFrameGrabber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettingsFrameGrabber" "', argument " "1"" of type '" "mvIMPACT::acquire::SettingsFrameGrabber *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SettingsFrameGrabber * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SettingsFrameGrabber_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__SettingsFrameGrabber, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SettingsFrameGrabber_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SystemBlueFOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::SystemBlueFOX *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SystemBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::SystemBlueFOX *)new mvIMPACT::acquire::SystemBlueFOX(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemBlueFOX_transferSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemBlueFOX *arg1 = (mvIMPACT::acquire::SystemBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBlueFOXTransferSize *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemBlueFOX_transferSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBlueFOXTransferSize *)& ((arg1)->transferSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemBlueFOX_footerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemBlueFOX *arg1 = (mvIMPACT::acquire::SystemBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBlueFOXFooterMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemBlueFOX_footerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBlueFOXFooterMode *)& ((arg1)->footerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemBlueFOX_footerCheckEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemBlueFOX *arg1 = (mvIMPACT::acquire::SystemBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemBlueFOX_footerCheckEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->footerCheckEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemBlueFOX_powerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemBlueFOX *arg1 = (mvIMPACT::acquire::SystemBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIDevicePowerMode *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemBlueFOX_powerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIDevicePowerMode *)& ((arg1)->powerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemBlueFOX_statusLEDEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::SystemBlueFOX *arg1 = (mvIMPACT::acquire::SystemBlueFOX *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemBlueFOX_statusLEDEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemBlueFOX * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->statusLEDEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SystemBlueFOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SystemBlueFOX *arg1 = (mvIMPACT::acquire::SystemBlueFOX *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SystemBlueFOX" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemBlueFOX *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemBlueFOX * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SystemBlueFOX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SystemBlueFOX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SystemV4L2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::SystemV4L2 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SystemV4L2" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::SystemV4L2 *)new mvIMPACT::acquire::SystemV4L2(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemV4L2_volume_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SystemV4L2 *arg1 = (mvIMPACT::acquire::SystemV4L2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemV4L2_volume_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemV4L2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemV4L2 * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->volume); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemV4L2_balance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SystemV4L2 *arg1 = (mvIMPACT::acquire::SystemV4L2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemV4L2_balance_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemV4L2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemV4L2 * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->balance); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemV4L2_bass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SystemV4L2 *arg1 = (mvIMPACT::acquire::SystemV4L2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemV4L2_bass_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemV4L2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemV4L2 * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->bass); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemV4L2_treble_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SystemV4L2 *arg1 = (mvIMPACT::acquire::SystemV4L2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemV4L2_treble_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemV4L2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemV4L2 * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->treble); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemV4L2_mute_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SystemV4L2 *arg1 = (mvIMPACT::acquire::SystemV4L2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemV4L2_mute_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemV4L2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemV4L2 * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mute); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemV4L2_loudness_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SystemV4L2 *arg1 = (mvIMPACT::acquire::SystemV4L2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemV4L2_loudness_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemV4L2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemV4L2 * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->loudness); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SystemV4L2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::SystemV4L2 *arg1 = (mvIMPACT::acquire::SystemV4L2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SystemV4L2" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemV4L2 *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemV4L2 * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SystemV4L2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SystemV4L2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FirmwareUpdater_setTimeElapsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; double arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  SwigDirector_FirmwareUpdater *darg = 0;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_setTimeElapsed", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_setTimeElapsed" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_setTimeElapsed" "', argument " "2"" of type '" "double""'"); }
    arg2 = static_cast< double >(val2); darg = dynamic_cast<SwigDirector_FirmwareUpdater *>(arg1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; (darg)->setTimeElapsed(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FirmwareUpdater__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ;
  bool arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; bool val4 ;
  int ecode4 = 0 ; bool val5 ; int ecode5 = 0 ; bool val6 ; int ecode6 = 0 ; mvIMPACT::acquire::FirmwareUpdater *result = 0 ;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FirmwareUpdater" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FirmwareUpdater" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FirmwareUpdater" "', argument " "4"" of type '" "bool""'"); }
    arg4 = static_cast< bool >(val4); ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FirmwareUpdater" "', argument " "5"" of type '" "bool""'"); }
    arg5 = static_cast< bool >(val5); ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FirmwareUpdater" "', argument " "6"" of type '" "bool""'"); }
    arg6 = static_cast< bool >(val6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if ( arg1 != Py_None ) { 
          result = (mvIMPACT::acquire::FirmwareUpdater *)new SwigDirector_FirmwareUpdater(arg1,arg2,arg3,arg4,arg5,arg6);  }
         else {
          result = (mvIMPACT::acquire::FirmwareUpdater *)new mvIMPACT::acquire::FirmwareUpdater(arg2,arg3,arg4,arg5,arg6);  } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FirmwareUpdater__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ;
  bool arg3 ; bool arg4 ; bool arg5 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ;
  bool val5 ; int ecode5 = 0 ; mvIMPACT::acquire::FirmwareUpdater *result = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = swig_obj[0]; res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FirmwareUpdater" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FirmwareUpdater" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FirmwareUpdater" "', argument " "4"" of type '" "bool""'"); }
    arg4 = static_cast< bool >(val4); ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FirmwareUpdater" "', argument " "5"" of type '" "bool""'"); }
    arg5 = static_cast< bool >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if ( arg1 != Py_None ) { 
          result = (mvIMPACT::acquire::FirmwareUpdater *)new SwigDirector_FirmwareUpdater(arg1,arg2,arg3,arg4,arg5);  }  else {
          result = (mvIMPACT::acquire::FirmwareUpdater *)new mvIMPACT::acquire::FirmwareUpdater(arg2,arg3,arg4,arg5);  } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FirmwareUpdater__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ;
  bool arg3 ; bool arg4 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::FirmwareUpdater *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FirmwareUpdater" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FirmwareUpdater" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FirmwareUpdater" "', argument " "4"" of type '" "bool""'"); }
    arg4 = static_cast< bool >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if ( arg1 != Py_None ) { 
          result = (mvIMPACT::acquire::FirmwareUpdater *)new SwigDirector_FirmwareUpdater(arg1,arg2,arg3,arg4);  }  else {
          result = (mvIMPACT::acquire::FirmwareUpdater *)new mvIMPACT::acquire::FirmwareUpdater(arg2,arg3,arg4);  } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FirmwareUpdater__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ;
  bool arg3 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::FirmwareUpdater *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FirmwareUpdater" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FirmwareUpdater" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if ( arg1 != Py_None ) { 
          result = (mvIMPACT::acquire::FirmwareUpdater *)new SwigDirector_FirmwareUpdater(arg1,arg2,arg3);  }  else {
          result = (mvIMPACT::acquire::FirmwareUpdater *)new mvIMPACT::acquire::FirmwareUpdater(arg2,arg3);  } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FirmwareUpdater__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ;
  void *argp2 = 0 ; int res2 = 0 ; mvIMPACT::acquire::FirmwareUpdater *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0]; res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FirmwareUpdater" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {  result = (mvIMPACT::acquire::FirmwareUpdater *)new SwigDirector_FirmwareUpdater(arg1,arg2);  }
         else { result = (mvIMPACT::acquire::FirmwareUpdater *)new mvIMPACT::acquire::FirmwareUpdater(arg2);  } 
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FirmwareUpdater(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[7] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FirmwareUpdater", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_FirmwareUpdater__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_FirmwareUpdater__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_new_FirmwareUpdater__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_new_FirmwareUpdater__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 6) {
    PyObject *retobj = _wrap_new_FirmwareUpdater__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FirmwareUpdater'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FirmwareUpdater::FirmwareUpdater(mvIMPACT::acquire::Device *,bool,bool,bool,bool)\n"
  "    mvIMPACT::acquire::FirmwareUpdater::FirmwareUpdater(mvIMPACT::acquire::Device *,bool,bool,bool)\n"
  "    mvIMPACT::acquire::FirmwareUpdater::FirmwareUpdater(mvIMPACT::acquire::Device *,bool,bool)\n"
  "    mvIMPACT::acquire::FirmwareUpdater::FirmwareUpdater(mvIMPACT::acquire::Device *,bool)\n"
  "    mvIMPACT::acquire::FirmwareUpdater::FirmwareUpdater(PyObject *,mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_FirmwareUpdater(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FirmwareUpdater" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_onErrorMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; double arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ; Swig::Director *director = 0;
  bool upcall = false; int result;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_onErrorMessage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_onErrorMessage" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_onErrorMessage" "', argument " "2"" of type '" "double""'"); }
    arg2 = static_cast< double >(val2); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->mvIMPACT::acquire::FirmwareUpdater::onErrorMessage(arg2); }
         else { result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->onErrorMessage(arg2); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_onErasingFlash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; int arg2 ;
  double arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double val3 ; int ecode3 = 0 ;
  PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; int result;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_onErasingFlash", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_onErasingFlash" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_onErasingFlash" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FirmwareUpdater_onErasingFlash" "', argument " "3"" of type '" "double""'"); }
    arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->mvIMPACT::acquire::FirmwareUpdater::onErasingFlash(arg2,arg3); }
         else { result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->onErasingFlash(arg2,arg3); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_onUnzippingFirmwareArchive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; int arg2 ;
  double arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double val3 ; int ecode3 = 0 ;
  PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; int result;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_onUnzippingFirmwareArchive", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_onUnzippingFirmwareArchive" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_onUnzippingFirmwareArchive" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FirmwareUpdater_onUnzippingFirmwareArchive" "', argument " "3"" of type '" "double""'"); }
    arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->mvIMPACT::acquire::FirmwareUpdater::onUnzippingFirmwareArchive(arg2,arg3); }
         else { result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->onUnzippingFirmwareArchive(arg2,arg3); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_onUpdatingBootProgrammer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; int arg2 ;
  double arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double val3 ; int ecode3 = 0 ;
  PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; int result;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_onUpdatingBootProgrammer", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_onUpdatingBootProgrammer" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_onUpdatingBootProgrammer" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FirmwareUpdater_onUpdatingBootProgrammer" "', argument " "3"" of type '" "double""'"); }
    arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->mvIMPACT::acquire::FirmwareUpdater::onUpdatingBootProgrammer(arg2,arg3); }
         else { result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->onUpdatingBootProgrammer(arg2,arg3); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_onUploadingImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; int arg2 ;
  double arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double val3 ; int ecode3 = 0 ;
  PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; int result;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_onUploadingImage", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_onUploadingImage" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_onUploadingImage" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FirmwareUpdater_onUploadingImage" "', argument " "3"" of type '" "double""'"); }
    arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->mvIMPACT::acquire::FirmwareUpdater::onUploadingImage(arg2,arg3); }
         else { result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->onUploadingImage(arg2,arg3); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_onRebooting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; int arg2 ;
  double arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double val3 ; int ecode3 = 0 ;
  PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; int result;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_onRebooting", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_onRebooting" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_onRebooting" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FirmwareUpdater_onRebooting" "', argument " "3"" of type '" "double""'"); }
    arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->mvIMPACT::acquire::FirmwareUpdater::onRebooting(arg2,arg3); }
         else { result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->onRebooting(arg2,arg3); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_onHardResetRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; int arg2 ;
  double arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double val3 ; int ecode3 = 0 ;
  PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; int result;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_onHardResetRequired", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_onHardResetRequired" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_onHardResetRequired" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FirmwareUpdater_onHardResetRequired" "', argument " "3"" of type '" "double""'"); }
    arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->mvIMPACT::acquire::FirmwareUpdater::onHardResetRequired(arg2,arg3); }
         else { result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->onHardResetRequired(arg2,arg3); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_onSavingUserSets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; int arg2 ;
  double arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double val3 ; int ecode3 = 0 ;
  PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; int result;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_onSavingUserSets", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_onSavingUserSets" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_onSavingUserSets" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FirmwareUpdater_onSavingUserSets" "', argument " "3"" of type '" "double""'"); }
    arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->mvIMPACT::acquire::FirmwareUpdater::onSavingUserSets(arg2,arg3); }
         else { result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->onSavingUserSets(arg2,arg3); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_onLoadingUserSets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; int arg2 ;
  double arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double val3 ; int ecode3 = 0 ;
  PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; int result;
  if (!SWIG_Python_UnpackTuple(args, "FirmwareUpdater_onLoadingUserSets", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_onLoadingUserSets" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FirmwareUpdater_onLoadingUserSets" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FirmwareUpdater_onLoadingUserSets" "', argument " "3"" of type '" "double""'"); }
    arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) {
          result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->mvIMPACT::acquire::FirmwareUpdater::onLoadingUserSets(arg2,arg3); }
         else { result = (int)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->onLoadingUserSets(arg2,arg3); }  } 
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
      catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  }  catch (Swig::DirectorException&) {
    SWIG_fail; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ;
  std::string *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::TDMR_ERROR result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_update" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FirmwareUpdater_update" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FirmwareUpdater_update" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FirmwareUpdater_update" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDMR_ERROR)(arg1)->update((std::string const &)*arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::TDMR_ERROR result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_update" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FirmwareUpdater_update" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FirmwareUpdater_update" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDMR_ERROR)(arg1)->update((std::string const &)*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_update__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDMR_ERROR result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_update" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDMR_ERROR)(arg1)->update(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_update(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FirmwareUpdater_update", 0, 3, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_FirmwareUpdater_update__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_FirmwareUpdater_update__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_FirmwareUpdater_update__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FirmwareUpdater_update'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::FirmwareUpdater::update(std::string const &,bool const)\n"
  "    mvIMPACT::acquire::FirmwareUpdater::update(std::string const &)\n" "    mvIMPACT::acquire::FirmwareUpdater::update()\n");
  return 0; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_statusMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_statusMessage" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->statusMessage(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_getTimeElapsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; double result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_getTimeElapsed" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((mvIMPACT::acquire::FirmwareUpdater const *)arg1)->getTimeElapsed(); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_verifyFirmwareChecksum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  std::string *arg3 = (std::string *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; void *argp3 = 0 ;
  int res3 = 0 ; mvIMPACT::acquire::TDMR_ERROR result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_verifyFirmwareChecksum" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FirmwareUpdater_verifyFirmwareChecksum" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FirmwareUpdater_verifyFirmwareChecksum" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_std__string, 0 |  0 ); if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FirmwareUpdater_verifyFirmwareChecksum" "', argument " "3"" of type '" "std::string *""'");  }
   arg3 = reinterpret_cast< std::string * >(argp3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDMR_ERROR)mvIMPACT::acquire::FirmwareUpdater::verifyFirmwareChecksum(arg1,(std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_verifyFirmwareChecksum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::TDMR_ERROR result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_verifyFirmwareChecksum" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FirmwareUpdater_verifyFirmwareChecksum" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FirmwareUpdater_verifyFirmwareChecksum" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDMR_ERROR)mvIMPACT::acquire::FirmwareUpdater::verifyFirmwareChecksum(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_verifyFirmwareChecksum(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "FirmwareUpdater_verifyFirmwareChecksum", 0, 3, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_FirmwareUpdater_verifyFirmwareChecksum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_FirmwareUpdater_verifyFirmwareChecksum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FirmwareUpdater_verifyFirmwareChecksum'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FirmwareUpdater::verifyFirmwareChecksum(mvIMPACT::acquire::Device *,std::string const &,std::string *)\n"
  "    mvIMPACT::acquire::FirmwareUpdater::verifyFirmwareChecksum(mvIMPACT::acquire::Device *,std::string const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_FirmwareUpdater_firmwareVersionToUpload_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FirmwareUpdater_firmwareVersionToUpload_get" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->firmwareVersionToUpload); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_disown_FirmwareUpdater(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::FirmwareUpdater *arg1 = (mvIMPACT::acquire::FirmwareUpdater *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_FirmwareUpdater" "', argument " "1"" of type '" "mvIMPACT::acquire::FirmwareUpdater *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::FirmwareUpdater * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); if (director) director->swig_disown(); } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *FirmwareUpdater_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__FirmwareUpdater, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FirmwareUpdater_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GenTLProducerConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenTLProducerConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenTLProducerConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *)new mvIMPACT::acquire::GenICam::GenTLProducerConfiguration((mvIMPACT::acquire::GenICam::GenTLProducerConfiguration const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_GenTLProducerConfiguration_enumerationEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *arg1 = (mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLProducerConfiguration_enumerationEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->enumerationEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_GenTLProducerConfiguration_getInterfaceEnumerationBehaviour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *arg1 = (mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  SwigValueWrapper< mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > result;
  if (!SWIG_Python_UnpackTuple(args, "GenTLProducerConfiguration_getInterfaceEnumerationBehaviour", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLProducerConfiguration_getInterfaceEnumerationBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenTLProducerConfiguration_getInterfaceEnumerationBehaviour" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenTLProducerConfiguration_getInterfaceEnumerationBehaviour" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::GenICam::GenTLProducerConfiguration const *)arg1)->getInterfaceEnumerationBehaviour((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour(static_cast< const mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour& >(result))), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_GenTLProducerConfiguration_getInterfaceEnumerationBehaviours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *arg1 = (mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< std::string,mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > > result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLProducerConfiguration_getInterfaceEnumerationBehaviours" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::GenICam::GenTLProducerConfiguration const *)arg1)->getInterfaceEnumerationBehaviours();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new std::map< std::string,mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour >(static_cast< const std::map< std::string,mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour >& >(result))), SWIGTYPE_p_std__mapT_std__string_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_GenTLProducerConfiguration_createProducerInterfaceConfigurationEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *arg1 = (mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  SwigValueWrapper< mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > result;
  if (!SWIG_Python_UnpackTuple(args, "GenTLProducerConfiguration_createProducerInterfaceConfigurationEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLProducerConfiguration_createProducerInterfaceConfigurationEntry" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenTLProducerConfiguration_createProducerInterfaceConfigurationEntry" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenTLProducerConfiguration_createProducerInterfaceConfigurationEntry" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->createProducerInterfaceConfigurationEntry((std::string const &)*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour(static_cast< const mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour& >(result))), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_GenTLProducerConfiguration_deleteProducerInterfaceConfigurationEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *arg1 = (mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "GenTLProducerConfiguration_deleteProducerInterfaceConfigurationEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLProducerConfiguration_deleteProducerInterfaceConfigurationEntry" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenTLProducerConfiguration_deleteProducerInterfaceConfigurationEntry" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenTLProducerConfiguration_deleteProducerInterfaceConfigurationEntry" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->deleteProducerInterfaceConfigurationEntry((std::string const &)*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_GenTLProducerConfiguration_getProducerName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *arg1 = (mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLProducerConfiguration_getProducerName" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::GenICam::GenTLProducerConfiguration const *)arg1)->getProducerName();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_GenTLProducerConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *arg1 = (mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenTLProducerConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *GenTLProducerConfiguration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GenTLProducerConfiguration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GenTLDriverConfigurator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *)new mvIMPACT::acquire::GenICam::GenTLDriverConfigurator();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_GenTLDriverConfigurator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenTLDriverConfigurator" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenTLDriverConfigurator" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *)new mvIMPACT::acquire::GenICam::GenTLDriverConfigurator((mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_GenTLDriverConfigurator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_GenTLDriverConfigurator", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_GenTLDriverConfigurator__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_GenTLDriverConfigurator__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GenTLDriverConfigurator'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::GenICam::GenTLDriverConfigurator::GenTLDriverConfigurator()\n"
  "    mvIMPACT::acquire::GenICam::GenTLDriverConfigurator::GenTLDriverConfigurator(mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_GenTLDriverConfigurator_masterEnumerationBehaviour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLDriverConfigurator_masterEnumerationBehaviour_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour *)& ((arg1)->masterEnumerationBehaviour);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_GenTLDriverConfigurator_createProducerConfiguration__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) 0 ;
  std::string *arg2 = 0 ; std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ; SwigValueWrapper< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration > result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLDriverConfigurator_createProducerConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenTLDriverConfigurator_createProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenTLDriverConfigurator_createProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { std::string *ptr = (std::string *)0; res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenTLDriverConfigurator_createProducerConfiguration" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenTLDriverConfigurator_createProducerConfiguration" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->createProducerConfiguration((std::string const &)*arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::GenICam::GenTLProducerConfiguration(static_cast< const mvIMPACT::acquire::GenICam::GenTLProducerConfiguration& >(result))), SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_GenTLDriverConfigurator_createProducerConfiguration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration > result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLDriverConfigurator_createProducerConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenTLDriverConfigurator_createProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenTLDriverConfigurator_createProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->createProducerConfiguration((std::string const &)*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::GenICam::GenTLProducerConfiguration(static_cast< const mvIMPACT::acquire::GenICam::GenTLProducerConfiguration& >(result))), SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_GenTLDriverConfigurator_createProducerConfiguration(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "GenTLDriverConfigurator_createProducerConfiguration", 0, 3, argv))) SWIG_fail;
  --argc; if (argc == 2) {
    PyObject *retobj = _wrap_GenTLDriverConfigurator_createProducerConfiguration__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_GenTLDriverConfigurator_createProducerConfiguration__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GenTLDriverConfigurator_createProducerConfiguration'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::GenTLDriverConfigurator::createProducerConfiguration(std::string const &,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::GenTLDriverConfigurator::createProducerConfiguration(std::string const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_GenTLDriverConfigurator_deleteProducerConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "GenTLDriverConfigurator_deleteProducerConfiguration", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLDriverConfigurator_deleteProducerConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenTLDriverConfigurator_deleteProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenTLDriverConfigurator_deleteProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->deleteProducerConfiguration((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_GenTLDriverConfigurator_deleteAllProducerConfigurations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLDriverConfigurator_deleteAllProducerConfigurations" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->deleteAllProducerConfigurations(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_GenTLDriverConfigurator_hasProducerConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args, "GenTLDriverConfigurator_hasProducerConfiguration", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLDriverConfigurator_hasProducerConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenTLDriverConfigurator_hasProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenTLDriverConfigurator_hasProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const *)arg1)->hasProducerConfiguration((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_GenTLDriverConfigurator_getProducerConfiguration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  SwigValueWrapper< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration > result;
  if (!SWIG_Python_UnpackTuple(args, "GenTLDriverConfigurator_getProducerConfiguration", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLDriverConfigurator_getProducerConfiguration" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenTLDriverConfigurator_getProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenTLDriverConfigurator_getProducerConfiguration" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const *)arg1)->getProducerConfiguration((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::GenICam::GenTLProducerConfiguration(static_cast< const mvIMPACT::acquire::GenICam::GenTLProducerConfiguration& >(result))), SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_GenTLDriverConfigurator_getProducerConfigurations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration,std::allocator< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration > > > result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenTLDriverConfigurator_getProducerConfigurations" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::GenICam::GenTLDriverConfigurator const *)arg1)->getProducerConfigurations();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj((new std::vector< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration,std::allocator< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration > >(static_cast< const std::vector< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration,std::allocator< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration > >& >(result))), SWIGTYPE_p_std__vectorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_std__allocatorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_GenTLDriverConfigurator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *arg1 = (mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenTLDriverConfigurator" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::GenTLDriverConfigurator * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *GenTLDriverConfigurator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GenTLDriverConfigurator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; mvIMPACT::acquire::ImageBuffer *arg2 = (mvIMPACT::acquire::ImageBuffer *) 0 ;
  mvIMPACT::acquire::TVideoCodec arg3 ; unsigned int arg4 ; unsigned int arg5 ; int res1 = SWIG_OLDOBJ ; void *argp2 = 0 ;
  int res2 = 0 ; int val3 ; int ecode3 = 0 ; unsigned int val4 ; int ecode4 = 0 ; unsigned int val5 ; int ecode5 = 0 ;
  mvIMPACT::acquire::labs::VideoStream *result = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageBuffer const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TVideoCodec >(val3); ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoStream" "', argument " "4"" of type '" "unsigned int""'"); }
    arg4 = static_cast< unsigned int >(val4); ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_VideoStream" "', argument " "5"" of type '" "unsigned int""'"); }
    arg5 = static_cast< unsigned int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,(mvIMPACT::acquire::ImageBuffer const *)arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; mvIMPACT::acquire::ImageBuffer *arg2 = (mvIMPACT::acquire::ImageBuffer *) 0 ;
  mvIMPACT::acquire::TVideoCodec arg3 ; unsigned int arg4 ; int res1 = SWIG_OLDOBJ ; void *argp2 = 0 ; int res2 = 0 ; int val3 ;
  int ecode3 = 0 ; unsigned int val4 ; int ecode4 = 0 ; mvIMPACT::acquire::labs::VideoStream *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageBuffer const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TVideoCodec >(val3); ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoStream" "', argument " "4"" of type '" "unsigned int""'"); }
    arg4 = static_cast< unsigned int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,(mvIMPACT::acquire::ImageBuffer const *)arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; mvIMPACT::acquire::ImageBuffer *arg2 = (mvIMPACT::acquire::ImageBuffer *) 0 ;
  mvIMPACT::acquire::TVideoCodec arg3 ; int res1 = SWIG_OLDOBJ ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::labs::VideoStream *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageBuffer const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TVideoCodec >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,(mvIMPACT::acquire::ImageBuffer const *)arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; mvIMPACT::acquire::ImageBuffer *arg2 = (mvIMPACT::acquire::ImageBuffer *) 0 ;
  int res1 = SWIG_OLDOBJ ; void *argp2 = 0 ; int res2 = 0 ; mvIMPACT::acquire::labs::VideoStream *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageBuffer const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,(mvIMPACT::acquire::ImageBuffer const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; unsigned int arg2 ; unsigned int arg3 ; mvIMPACT::acquire::TVideoCodec arg4 ;
  unsigned int arg5 ; unsigned int arg6 ; int res1 = SWIG_OLDOBJ ; unsigned int val2 ; int ecode2 = 0 ; unsigned int val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; unsigned int val5 ; int ecode5 = 0 ; unsigned int val6 ; int ecode6 = 0 ;
  mvIMPACT::acquire::labs::VideoStream *result = 0 ; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoStream" "', argument " "4"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg4 = static_cast< mvIMPACT::acquire::TVideoCodec >(val4); ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_VideoStream" "', argument " "5"" of type '" "unsigned int""'"); }
    arg5 = static_cast< unsigned int >(val5); ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_VideoStream" "', argument " "6"" of type '" "unsigned int""'"); }
    arg6 = static_cast< unsigned int >(val6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,arg2,arg3,arg4,arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; unsigned int arg2 ; unsigned int arg3 ; mvIMPACT::acquire::TVideoCodec arg4 ;
  unsigned int arg5 ; int res1 = SWIG_OLDOBJ ; unsigned int val2 ; int ecode2 = 0 ; unsigned int val3 ; int ecode3 = 0 ;
  int val4 ; int ecode4 = 0 ; unsigned int val5 ; int ecode5 = 0 ; mvIMPACT::acquire::labs::VideoStream *result = 0 ;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoStream" "', argument " "4"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg4 = static_cast< mvIMPACT::acquire::TVideoCodec >(val4); ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_VideoStream" "', argument " "5"" of type '" "unsigned int""'"); }
    arg5 = static_cast< unsigned int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; unsigned int arg2 ; unsigned int arg3 ; mvIMPACT::acquire::TVideoCodec arg4 ;
  int res1 = SWIG_OLDOBJ ; unsigned int val2 ; int ecode2 = 0 ; unsigned int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::labs::VideoStream *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoStream" "', argument " "4"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg4 = static_cast< mvIMPACT::acquire::TVideoCodec >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; unsigned int arg2 ; unsigned int arg3 ; int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ; int ecode2 = 0 ; unsigned int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::labs::VideoStream *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "unsigned int""'"); }
    arg2 = static_cast< unsigned int >(val2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ;
  mvIMPACT::acquire::TVideoCodec arg3 ; unsigned int arg4 ; unsigned int arg5 ; int res1 = SWIG_OLDOBJ ; void *argp2 = 0 ;
  int res2 = 0 ; int val3 ; int ecode3 = 0 ; unsigned int val4 ; int ecode4 = 0 ; unsigned int val5 ; int ecode5 = 0 ;
  mvIMPACT::acquire::labs::VideoStream *result = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TVideoCodec >(val3); ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoStream" "', argument " "4"" of type '" "unsigned int""'"); }
    arg4 = static_cast< unsigned int >(val4); ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_VideoStream" "', argument " "5"" of type '" "unsigned int""'"); }
    arg5 = static_cast< unsigned int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,(mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ;
  mvIMPACT::acquire::TVideoCodec arg3 ; unsigned int arg4 ; int res1 = SWIG_OLDOBJ ; void *argp2 = 0 ; int res2 = 0 ; int val3 ;
  int ecode3 = 0 ; unsigned int val4 ; int ecode4 = 0 ; mvIMPACT::acquire::labs::VideoStream *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TVideoCodec >(val3); ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoStream" "', argument " "4"" of type '" "unsigned int""'"); }
    arg4 = static_cast< unsigned int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,(mvIMPACT::acquire::Request const *)arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ;
  mvIMPACT::acquire::TVideoCodec arg3 ; int res1 = SWIG_OLDOBJ ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::labs::VideoStream *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; {
    std::string *ptr = (std::string *)0; res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoStream" "', argument " "3"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg3 = static_cast< mvIMPACT::acquire::TVideoCodec >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,(mvIMPACT::acquire::Request const *)arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string *arg1 = 0 ; mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ;
  int res1 = SWIG_OLDOBJ ; void *argp2 = 0 ; int res2 = 0 ; mvIMPACT::acquire::labs::VideoStream *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStream" "', argument " "1"" of type '" "std::string const &""'"); }
     arg1 = ptr; }  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VideoStream" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStream *)new mvIMPACT::acquire::labs::VideoStream((std::string const &)*arg1,(mvIMPACT::acquire::Request const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStream(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[7] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_VideoStream", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; {
      void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; return _wrap_new_VideoStream__SWIG_3(self, argc, argv);}  check_1:
  if (argc == 2) { PyObject *retobj = _wrap_new_VideoStream__SWIG_11(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Request, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_new_VideoStream__SWIG_10(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_4; { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_new_VideoStream__SWIG_2(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_new_VideoStream__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Request, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_6; { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6; {
      { int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_new_VideoStream__SWIG_9(self, argc, argv);}  check_6: if (argc == 4) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_7; { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_7; {
      { int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_7;
    return _wrap_new_VideoStream__SWIG_1(self, argc, argv);}  check_7: if (argc == 4) {
    PyObject *retobj = _wrap_new_VideoStream__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_9; { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_9; {
      { int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_9;
    PyObject *retobj = _wrap_new_VideoStream__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_9: if (argc == 5) { int _v = 0; {
      void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Request, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_10; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_10; { { int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_10;
    PyObject *retobj = _wrap_new_VideoStream__SWIG_8(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_10: if (argc == 5) {
    PyObject *retobj = _wrap_new_VideoStream__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 6) {
    PyObject *retobj = _wrap_new_VideoStream__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VideoStream'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,mvIMPACT::acquire::ImageBuffer const *,mvIMPACT::acquire::TVideoCodec const,unsigned int const,unsigned int const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,mvIMPACT::acquire::ImageBuffer const *,mvIMPACT::acquire::TVideoCodec const,unsigned int const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,mvIMPACT::acquire::ImageBuffer const *,mvIMPACT::acquire::TVideoCodec const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,mvIMPACT::acquire::ImageBuffer const *)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,unsigned int const,unsigned int const,mvIMPACT::acquire::TVideoCodec const,unsigned int const,unsigned int const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,unsigned int const,unsigned int const,mvIMPACT::acquire::TVideoCodec const,unsigned int const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,unsigned int const,unsigned int const,mvIMPACT::acquire::TVideoCodec const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,unsigned int const,unsigned int const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,mvIMPACT::acquire::Request const *,mvIMPACT::acquire::TVideoCodec const,unsigned int const,unsigned int const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,mvIMPACT::acquire::Request const *,mvIMPACT::acquire::TVideoCodec const,unsigned int const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,mvIMPACT::acquire::Request const *,mvIMPACT::acquire::TVideoCodec const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::VideoStream(std::string const &,mvIMPACT::acquire::Request const *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_delete_VideoStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoStream" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_getFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoStream_getFileName" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::string *) &((mvIMPACT::acquire::labs::VideoStream const *)arg1)->getFileName();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_getCodec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::TVideoCodec *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoStream_getCodec" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVideoCodec *) &((mvIMPACT::acquire::labs::VideoStream const *)arg1)->getCodec();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_getCodecAsString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TVideoCodec arg1 ; int val1 ; int ecode1 = 0 ; std::string result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "VideoStream_getCodecAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::TVideoCodec""'"); }
    arg1 = static_cast< mvIMPACT::acquire::TVideoCodec >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = mvIMPACT::acquire::labs::VideoStream::getCodecAsString(arg1); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_getCodecAsString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoStream_getCodecAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::labs::VideoStream const *)arg1)->getCodecAsString(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_getCodecAsString(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "VideoStream_getCodecAsString", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 1) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0); _v = SWIG_CheckState(res);}
     if (!_v) goto check_1; return _wrap_VideoStream_getCodecAsString__SWIG_1(self, argc, argv);}  check_1: if (argc == 1) {
    PyObject *retobj = _wrap_VideoStream_getCodecAsString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VideoStream_getCodecAsString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::labs::VideoStream::getCodecAsString(mvIMPACT::acquire::TVideoCodec const)\n"
  "    mvIMPACT::acquire::labs::VideoStream::getCodecAsString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_VideoStream_isAPIAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  bool result; if (!SWIG_Python_UnpackTuple(args, "VideoStream_isAPIAvailable", 0, 0, 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (bool)mvIMPACT::acquire::labs::VideoStream::isAPIAvailable();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_saveImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ;
  mvIMPACT::acquire::ImageBuffer *arg2 = (mvIMPACT::acquire::ImageBuffer *) 0 ; int64_type arg3 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; long val3 ; int ecode3 = 0 ; int result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoStream_saveImage" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoStream_saveImage" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageBuffer const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp2); ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VideoStream_saveImage" "', argument " "3"" of type '" "int64_type""'"); }
    arg3 = static_cast< int64_type >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->saveImage((mvIMPACT::acquire::ImageBuffer const *)arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_saveImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ;
  mvIMPACT::acquire::ImageBuffer *arg2 = (mvIMPACT::acquire::ImageBuffer *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoStream_saveImage" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoStream_saveImage" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageBuffer const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageBuffer * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->saveImage((mvIMPACT::acquire::ImageBuffer const *)arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_saveImage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ;
  mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ;
  mvIMPACT::acquire::Request *arg3 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoStream_saveImage" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoStream_saveImage" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VideoStream_saveImage" "', argument " "3"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg3 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->saveImage(arg2,(mvIMPACT::acquire::Request const *)arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_saveImage(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "VideoStream_saveImage", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_VideoStream_saveImage__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_2; { { int res = SWIG_AsVal_long(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_2;
    return _wrap_VideoStream_saveImage__SWIG_0(self, argc, argv);}  check_2: if (argc == 3) {
    PyObject *retobj = _wrap_VideoStream_saveImage__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VideoStream_saveImage'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::labs::VideoStream::saveImage(mvIMPACT::acquire::ImageBuffer const *,int64_type)\n"
  "    mvIMPACT::acquire::labs::VideoStream::saveImage(mvIMPACT::acquire::ImageBuffer const *)\n"
  "    mvIMPACT::acquire::labs::VideoStream::saveImage(mvIMPACT::acquire::Device *,mvIMPACT::acquire::Request const *)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_VideoStream_pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoStream_pause" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::labs::VideoStream const *)arg1)->pause(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_isPaused(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; bool result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoStream_isPaused" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((mvIMPACT::acquire::labs::VideoStream const *)arg1)->isPaused(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_VideoStream_resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::labs::VideoStream *arg1 = (mvIMPACT::acquire::labs::VideoStream *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoStream_resume" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::labs::VideoStream const *)arg1)->resume(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *VideoStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VideoStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VideoStreamPauseScope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::labs::VideoStream *arg1 = 0 ; bool arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  bool val2 ; int ecode2 = 0 ; mvIMPACT::acquire::labs::VideoStreamPauseScope *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream,  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStreamPauseScope" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStreamPauseScope" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1); ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoStreamPauseScope" "', argument " "2"" of type '" "bool""'"); }
    arg2 = static_cast< bool >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStreamPauseScope *)new mvIMPACT::acquire::labs::VideoStreamPauseScope(*arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStreamPauseScope, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStreamPauseScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::labs::VideoStream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::labs::VideoStreamPauseScope *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStream,  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VideoStreamPauseScope" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VideoStreamPauseScope" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStream &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStream * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::labs::VideoStreamPauseScope *)new mvIMPACT::acquire::labs::VideoStreamPauseScope(*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStreamPauseScope, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_VideoStreamPauseScope(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_VideoStreamPauseScope", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_VideoStreamPauseScope__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_VideoStreamPauseScope__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VideoStreamPauseScope'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::labs::VideoStreamPauseScope::VideoStreamPauseScope(mvIMPACT::acquire::labs::VideoStream &,bool)\n"
  "    mvIMPACT::acquire::labs::VideoStreamPauseScope::VideoStreamPauseScope(mvIMPACT::acquire::labs::VideoStream &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_VideoStreamPauseScope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::labs::VideoStreamPauseScope *arg1 = (mvIMPACT::acquire::labs::VideoStreamPauseScope *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStreamPauseScope, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoStreamPauseScope" "', argument " "1"" of type '" "mvIMPACT::acquire::labs::VideoStreamPauseScope *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::labs::VideoStreamPauseScope * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *VideoStreamPauseScope_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__labs__VideoStreamPauseScope, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VideoStreamPauseScope_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *)new mvIMPACT::acquire::EnumPropertyI< int >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyI" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *)new mvIMPACT::acquire::EnumPropertyI< int >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyI" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyI" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *)new mvIMPACT::acquire::EnumPropertyI< int >((mvIMPACT::acquire::EnumPropertyI< int > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyI", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyI__SWIG_0(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyI__SWIG_2(self, argc, argv);}  check_2:
  if (argc == 1) { PyObject *retobj = _wrap_new_PropertyI__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyI'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< int >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< int > const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< std::pair< std::string,int >,std::allocator< std::pair< std::string,int > > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if (!PyList_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, int> >* pV = new std::vector<std::pair< std::string, int> > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); {
    int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, int> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i) {
      std::pair< std::string, int>* resultptr = new std::pair< std::string, int>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_int_t, 1); if(!newItem) {
        SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyI_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< int >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyI_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< int >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  std::vector<int >* pV = new std::vector<int > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI_read" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getMaxValue(); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getMinValue(); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getStepWidth(); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  std::vector<int >* pV = new std::vector<int > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  std::vector<int >* pV = new std::vector<int > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  std::vector<int >* pV = new std::vector<int > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ;
  bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  std::vector<int >* pV = new std::vector<int > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI_read" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyI_read" "', argument " "5"" of type '" "int""'"); }  
  arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3,arg4,arg5); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  std::vector<int >* pV = new std::vector<int > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI_read" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  std::vector<int >* pV = new std::vector<int > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI_read" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyI_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2; return _wrap_PropertyI_read__SWIG_4(self, argc, argv);}
   check_2: if (argc == 2) { PyObject *retobj = _wrap_PropertyI_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyI_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyI_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyI_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyI_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< int >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::read(std::vector< int,std::allocator< int > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::read(std::vector< int,std::allocator< int > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::read(std::vector< int,std::allocator< int > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::read(std::vector< int,std::allocator< int > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::read(std::vector< int,std::allocator< int > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::read(std::vector< int,std::allocator< int > > &,bool) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI_write" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI_write" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  int lsize = PySequence_Length(swig_obj[1]);
    std::vector<int>* pV = new std::vector<int> (0); for( int i = 0; i < lsize; ++i ) {
      PyObject* objectValue = PyList_GetItem(swig_obj[1], i); if ( NULL == objectValue ) { SWIG_fail; } 
      PyErr_Restore(NULL, NULL, NULL);  int value = PyLong_AsLong(objectValue); if ( NULL != PyErr_Occurred() ) { SWIG_fail; } 
      pV->push_back(static_cast<int>(value)); }  arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write((std::vector< int,std::allocator< int > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int>::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  int lsize = PySequence_Length(swig_obj[1]);
    std::vector<int>* pV = new std::vector<int> (0); for( int i = 0; i < lsize; ++i ) {
      PyObject* objectValue = PyList_GetItem(swig_obj[1], i); if ( NULL == objectValue ) { SWIG_fail; } 
      PyErr_Restore(NULL, NULL, NULL);  int value = PyLong_AsLong(objectValue); if ( NULL != PyErr_Occurred() ) { SWIG_fail; } 
      pV->push_back(static_cast<int>(value)); }  arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write((std::vector< int,std::allocator< int > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int>::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  int lsize = PySequence_Length(swig_obj[1]);
    std::vector<int>* pV = new std::vector<int> (0); for( int i = 0; i < lsize; ++i ) {
      PyObject* objectValue = PyList_GetItem(swig_obj[1], i); if ( NULL == objectValue ) { SWIG_fail; } 
      PyErr_Restore(NULL, NULL, NULL);  int value = PyLong_AsLong(objectValue); if ( NULL != PyErr_Occurred() ) { SWIG_fail; } 
      pV->push_back(static_cast<int>(value)); }  arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI_write" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI_write" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write((std::vector< int,std::allocator< int > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int>::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; }  int lsize = PySequence_Length(swig_obj[1]);
    std::vector<int>* pV = new std::vector<int> (0); for( int i = 0; i < lsize; ++i ) {
      PyObject* objectValue = PyList_GetItem(swig_obj[1], i); if ( NULL == objectValue ) { SWIG_fail; } 
      PyErr_Restore(NULL, NULL, NULL);  int value = PyLong_AsLong(objectValue); if ( NULL != PyErr_Occurred() ) { SWIG_fail; } 
      pV->push_back(static_cast<int>(value)); }  arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI_write" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write((std::vector< int,std::allocator< int > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<int>::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<int>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1; return _wrap_PropertyI_write__SWIG_3(self, argc, argv);}
   check_1: if (argc == 2) { PyObject *retobj = _wrap_PropertyI_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyI_write__SWIG_5(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyI_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyI_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyI_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI_write'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< int >::write(int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::write(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::write(std::vector< int,std::allocator< int > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::write(std::vector< int,std::allocator< int > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::write(std::vector< int,std::allocator< int > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >::write(std::vector< int,std::allocator< int > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyI" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< int > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< int > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,int > *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::pair< std::string,int > *)new std::pair< std::string,int >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; int arg2 ; int val2 ; int ecode2 = 0 ; std::pair< std::string,int > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringint" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringint" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,int > *)new std::pair< std::string,int >(arg1,arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  }
     catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringint__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,int > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,int > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,int > *ptr = (std::pair< std::string,int > *)0; res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringint" "', argument " "1"" of type '" "std::pair< std::string,int > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringint" "', argument " "1"" of type '" "std::pair< std::string,int > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,int > *)new std::pair< std::string,int >((std::pair< std::string,int > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_int_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringint(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringint", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringint__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringint__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringint__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringint'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,int >::pair()\n"
  "    std::pair< std::string,int >::pair(std::string,int)\n"
  "    std::pair< std::string,int >::pair(std::pair< std::string,int > const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_pairstringint_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,int > *arg1 = (std::pair< std::string,int > *) 0 ; std::string *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringint_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_int_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringint_first_set" "', argument " "1"" of type '" "std::pair< std::string,int > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,int > * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringint_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringint_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringint_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,int > *arg1 = (std::pair< std::string,int > *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_int_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringint_first_get" "', argument " "1"" of type '" "std::pair< std::string,int > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,int > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringint_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,int > *arg1 = (std::pair< std::string,int > *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ;
  int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringint_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_int_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringint_second_set" "', argument " "1"" of type '" "std::pair< std::string,int > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,int > * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringint_second_set" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->second = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringint_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,int > *arg1 = (std::pair< std::string,int > *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_int_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringint_second_get" "', argument " "1"" of type '" "std::pair< std::string,int > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,int > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,int > *arg1 = (std::pair< std::string,int > *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringint" "', argument " "1"" of type '" "std::pair< std::string,int > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,int > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_int_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIAcquisitionField" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIAcquisitionField" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIAcquisitionField" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionField(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIAcquisitionField", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIAcquisitionField__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIAcquisitionField__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIAcquisitionField__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIAcquisitionField'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionField_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TAcquisitionField> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TAcquisitionField> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TAcquisitionField> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TAcquisitionField>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TAcquisitionField>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionField_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionField_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionField_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAcquisitionField result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionField_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAcquisitionField result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionField_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIAcquisitionField_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionField_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionField_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionField_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAcquisitionField result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionField_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAcquisitionField result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionField result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionField result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionField result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionField_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionField_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionField_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionField_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionField_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIAcquisitionField_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionField_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionField_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionField_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionField_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAcquisitionField_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAcquisitionField_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIAcquisitionField_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionField_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::read(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::read(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::read(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::read(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::read(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::read(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  mvIMPACT::acquire::TAcquisitionField arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionField_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionField""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionField >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionField_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  mvIMPACT::acquire::TAcquisitionField arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionField_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionField""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionField >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionField_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionField_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionField_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionField_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionField >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionField > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionField_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionField >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionField>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionField_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAcquisitionField_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAcquisitionField_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIAcquisitionField_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAcquisitionField_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionField_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::write(mvIMPACT::acquire::TAcquisitionField,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::write(mvIMPACT::acquire::TAcquisitionField) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::write(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::write(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::write(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >::write(std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIAcquisitionField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIAcquisitionField" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIAcquisitionField_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIAcquisitionField_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *)new std::pair< std::string,mvIMPACT::acquire::TAcquisitionField >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TAcquisitionField arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTAcquisitionField" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTAcquisitionField" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionField""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionField >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *)new std::pair< std::string,mvIMPACT::acquire::TAcquisitionField >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *ptr = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTAcquisitionField" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTAcquisitionField" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *)new std::pair< std::string,mvIMPACT::acquire::TAcquisitionField >((std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionField(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTAcquisitionField", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTAcquisitionField__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTAcquisitionField__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTAcquisitionField__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTAcquisitionField'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TAcquisitionField >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAcquisitionField >::pair(std::string,mvIMPACT::acquire::TAcquisitionField)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAcquisitionField >::pair(std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionField_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAcquisitionField_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionField_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTAcquisitionField_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTAcquisitionField_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionField_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionField_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionField_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  mvIMPACT::acquire::TAcquisitionField arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAcquisitionField_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionField_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTAcquisitionField_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionField""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionField >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionField_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionField result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionField_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TAcquisitionField) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTAcquisitionField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTAcquisitionField" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTAcquisitionField_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTAcquisitionField_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIAcquisitionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIAcquisitionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIAcquisitionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIAcquisitionMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIAcquisitionMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIAcquisitionMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIAcquisitionMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIAcquisitionMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TAcquisitionMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TAcquisitionMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TAcquisitionMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TAcquisitionMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TAcquisitionMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIAcquisitionMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAcquisitionMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAcquisitionMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIAcquisitionMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAcquisitionMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAcquisitionMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIAcquisitionMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAcquisitionMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAcquisitionMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::read(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::read(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::read(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::read(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::read(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::read(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  mvIMPACT::acquire::TAcquisitionMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  mvIMPACT::acquire::TAcquisitionMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionMode >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAcquisitionMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAcquisitionMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAcquisitionMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::write(mvIMPACT::acquire::TAcquisitionMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::write(mvIMPACT::acquire::TAcquisitionMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::write(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::write(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::write(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >::write(std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIAcquisitionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIAcquisitionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIAcquisitionMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIAcquisitionMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *)new std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TAcquisitionMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTAcquisitionMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTAcquisitionMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *)new std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTAcquisitionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTAcquisitionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *)new std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode >((std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTAcquisitionMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTAcquisitionMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTAcquisitionMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTAcquisitionMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTAcquisitionMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode >::pair(std::string,mvIMPACT::acquire::TAcquisitionMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode >::pair(std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAcquisitionMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTAcquisitionMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTAcquisitionMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  mvIMPACT::acquire::TAcquisitionMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAcquisitionMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTAcquisitionMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TAcquisitionMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTAcquisitionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTAcquisitionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTAcquisitionMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTAcquisitionMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionStartStopBehaviour__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionStartStopBehaviour__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIAcquisitionStartStopBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionStartStopBehaviour__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIAcquisitionStartStopBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIAcquisitionStartStopBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAcquisitionStartStopBehaviour(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIAcquisitionStartStopBehaviour", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIAcquisitionStartStopBehaviour__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIAcquisitionStartStopBehaviour__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIAcquisitionStartStopBehaviour__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIAcquisitionStartStopBehaviour'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionStartStopBehaviour_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TAcquisitionStartStopBehaviour> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TAcquisitionStartStopBehaviour> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TAcquisitionStartStopBehaviour> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TAcquisitionStartStopBehaviour>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TAcquisitionStartStopBehaviour>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionStartStopBehaviour_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionStartStopBehaviour_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TAcquisitionStartStopBehaviour result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAcquisitionStartStopBehaviour result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionStartStopBehaviour_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TAcquisitionStartStopBehaviour result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAcquisitionStartStopBehaviour result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionStartStopBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionStartStopBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionStartStopBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionStartStopBehaviour_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionStartStopBehaviour_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionStartStopBehaviour_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::read(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::read(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::read(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::read(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::read(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::read(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  mvIMPACT::acquire::TAcquisitionStartStopBehaviour arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionStartStopBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  mvIMPACT::acquire::TAcquisitionStartStopBehaviour arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionStartStopBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >* pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAcquisitionStartStopBehaviour_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAcquisitionStartStopBehaviour_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAcquisitionStartStopBehaviour_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::write(mvIMPACT::acquire::TAcquisitionStartStopBehaviour,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::write(mvIMPACT::acquire::TAcquisitionStartStopBehaviour) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::write(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::write(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::write(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::write(std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIAcquisitionStartStopBehaviour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIAcquisitionStartStopBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIAcquisitionStartStopBehaviour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIAcquisitionStartStopBehaviour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionStartStopBehaviour__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *)new std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionStartStopBehaviour__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TAcquisitionStartStopBehaviour arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTAcquisitionStartStopBehaviour" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTAcquisitionStartStopBehaviour" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionStartStopBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *)new std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionStartStopBehaviour__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *ptr = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTAcquisitionStartStopBehaviour" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTAcquisitionStartStopBehaviour" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *)new std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour >((std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAcquisitionStartStopBehaviour(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTAcquisitionStartStopBehaviour", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTAcquisitionStartStopBehaviour__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTAcquisitionStartStopBehaviour__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTAcquisitionStartStopBehaviour__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTAcquisitionStartStopBehaviour'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::pair(std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour >::pair(std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionStartStopBehaviour_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAcquisitionStartStopBehaviour_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionStartStopBehaviour_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTAcquisitionStartStopBehaviour_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTAcquisitionStartStopBehaviour_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionStartStopBehaviour_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionStartStopBehaviour_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionStartStopBehaviour_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  mvIMPACT::acquire::TAcquisitionStartStopBehaviour arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAcquisitionStartStopBehaviour_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionStartStopBehaviour_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTAcquisitionStartStopBehaviour_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TAcquisitionStartStopBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAcquisitionStartStopBehaviour_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAcquisitionStartStopBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAcquisitionStartStopBehaviour_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTAcquisitionStartStopBehaviour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTAcquisitionStartStopBehaviour" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTAcquisitionStartStopBehaviour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTAcquisitionStartStopBehaviour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIAoiMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAoiMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIAoiMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAoiMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIAoiMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIAoiMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAoiMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIAoiMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIAoiMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIAoiMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIAoiMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIAoiMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TAoiMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAoiMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAoiMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TAoiMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TAoiMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TAoiMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TAoiMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TAoiMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAoiMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAoiMode_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIAoiMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAoiMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAoiMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAoiMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAoiMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAoiMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAoiMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIAoiMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAoiMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAoiMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAoiMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAoiMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAoiMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAoiMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAoiMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAoiMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAoiMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAoiMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; int arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAoiMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAoiMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAoiMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; bool arg3 ; int arg4 ;
  int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAoiMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAoiMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIAoiMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; bool arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAoiMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAoiMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAoiMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAoiMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAoiMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAoiMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAoiMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAoiMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAoiMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIAoiMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAoiMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIAoiMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAoiMode_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::read(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::read(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::read(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::read(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::read(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::read(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  mvIMPACT::acquire::TAoiMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAoiMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAoiMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAoiMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAoiMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  mvIMPACT::acquire::TAoiMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAoiMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAoiMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAoiMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAoiMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; bool arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAoiMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAoiMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAoiMode >* pV = new std::vector<mvIMPACT::acquire::TAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAoiMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAoiMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAoiMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAoiMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIAoiMode_write__SWIG_5(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIAoiMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAoiMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAoiMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAoiMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::write(mvIMPACT::acquire::TAoiMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::write(mvIMPACT::acquire::TAoiMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::write(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::write(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::write(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >::write(std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIAoiMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIAoiMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIAoiMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIAoiMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTAoiMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAoiMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAoiMode > *)new std::pair< std::string,mvIMPACT::acquire::TAoiMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAoiMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TAoiMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TAoiMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTAoiMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTAoiMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TAoiMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAoiMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAoiMode > *)new std::pair< std::string,mvIMPACT::acquire::TAoiMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAoiMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAoiMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TAoiMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TAoiMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TAoiMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTAoiMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAoiMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTAoiMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAoiMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAoiMode > *)new std::pair< std::string,mvIMPACT::acquire::TAoiMode >((std::pair< std::string,mvIMPACT::acquire::TAoiMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAoiMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTAoiMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTAoiMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTAoiMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTAoiMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTAoiMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TAoiMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAoiMode >::pair(std::string,mvIMPACT::acquire::TAoiMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAoiMode >::pair(std::pair< std::string,mvIMPACT::acquire::TAoiMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTAoiMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAoiMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAoiMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAoiMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAoiMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTAoiMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTAoiMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAoiMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAoiMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAoiMode > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAoiMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAoiMode > *) 0 ;
  mvIMPACT::acquire::TAoiMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAoiMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAoiMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTAoiMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TAoiMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAoiMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->second = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAoiMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAoiMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAoiMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAoiMode > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::TAoiMode) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTAoiMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTAoiMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTAoiMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTAoiMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIAutoControlSpeed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoControlSpeed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIAutoControlSpeed" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoControlSpeed__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIAutoControlSpeed" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIAutoControlSpeed" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoControlSpeed(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIAutoControlSpeed", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIAutoControlSpeed__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIAutoControlSpeed__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIAutoControlSpeed__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIAutoControlSpeed'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoControlSpeed_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TAutoControlSpeed> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoControlSpeed> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoControlSpeed> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TAutoControlSpeed>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TAutoControlSpeed>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlSpeed_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoControlSpeed_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoControlSpeed_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoControlSpeed result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlSpeed_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoControlSpeed result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoControlSpeed_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIAutoControlSpeed_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoControlSpeed_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoControlSpeed_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoControlSpeed_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoControlSpeed result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoControlSpeed result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoControlSpeed result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoControlSpeed result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoControlSpeed result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlSpeed_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoControlSpeed_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoControlSpeed_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::read(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::read(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::read(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::read(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::read(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::read(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  mvIMPACT::acquire::TAutoControlSpeed arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoControlSpeed""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoControlSpeed >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  mvIMPACT::acquire::TAutoControlSpeed arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoControlSpeed""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoControlSpeed >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlSpeed >* pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlSpeed_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlSpeed>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoControlSpeed_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoControlSpeed_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoControlSpeed_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoControlSpeed_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoControlSpeed_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::write(mvIMPACT::acquire::TAutoControlSpeed,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::write(mvIMPACT::acquire::TAutoControlSpeed) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::write(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::write(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::write(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >::write(std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIAutoControlSpeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIAutoControlSpeed" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIAutoControlSpeed_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIAutoControlSpeed_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTAutoControlSpeed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *)new std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoControlSpeed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TAutoControlSpeed arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTAutoControlSpeed" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTAutoControlSpeed" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoControlSpeed""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoControlSpeed >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *)new std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoControlSpeed__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *ptr = (std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTAutoControlSpeed" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTAutoControlSpeed" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *)new std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed >((std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoControlSpeed(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTAutoControlSpeed", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTAutoControlSpeed__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTAutoControlSpeed__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTAutoControlSpeed__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTAutoControlSpeed'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed >::pair(std::string,mvIMPACT::acquire::TAutoControlSpeed)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed >::pair(std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTAutoControlSpeed_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoControlSpeed_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoControlSpeed_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTAutoControlSpeed_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTAutoControlSpeed_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoControlSpeed_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoControlSpeed_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoControlSpeed_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  mvIMPACT::acquire::TAutoControlSpeed arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoControlSpeed_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoControlSpeed_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTAutoControlSpeed_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoControlSpeed""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoControlSpeed >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoControlSpeed_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoControlSpeed result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoControlSpeed_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TAutoControlSpeed) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTAutoControlSpeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTAutoControlSpeed" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTAutoControlSpeed_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTAutoControlSpeed_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIAutoControlMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoControlMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIAutoControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoControlMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIAutoControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIAutoControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoControlMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIAutoControlMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIAutoControlMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIAutoControlMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIAutoControlMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIAutoControlMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoControlMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TAutoControlMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoControlMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoControlMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TAutoControlMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TAutoControlMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoControlMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIAutoControlMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoControlMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoControlMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoControlMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoControlMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIAutoControlMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoControlMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoControlMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoControlMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoControlMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoControlMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoControlMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoControlMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoControlMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoControlMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoControlMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIAutoControlMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoControlMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoControlMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoControlMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoControlMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIAutoControlMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoControlMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::read(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::read(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::read(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::read(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::read(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::read(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  mvIMPACT::acquire::TAutoControlMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoControlMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  mvIMPACT::acquire::TAutoControlMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoControlMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoControlMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoControlMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoControlMode >* pV = new std::vector<mvIMPACT::acquire::TAutoControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoControlMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoControlMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoControlMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoControlMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoControlMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIAutoControlMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoControlMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoControlMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::write(mvIMPACT::acquire::TAutoControlMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::write(mvIMPACT::acquire::TAutoControlMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::write(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::write(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::write(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >::write(std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIAutoControlMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIAutoControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIAutoControlMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIAutoControlMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTAutoControlMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *)new std::pair< std::string,mvIMPACT::acquire::TAutoControlMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoControlMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TAutoControlMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTAutoControlMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTAutoControlMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoControlMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *)new std::pair< std::string,mvIMPACT::acquire::TAutoControlMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoControlMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTAutoControlMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTAutoControlMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *)new std::pair< std::string,mvIMPACT::acquire::TAutoControlMode >((std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoControlMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTAutoControlMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTAutoControlMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTAutoControlMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTAutoControlMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTAutoControlMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TAutoControlMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoControlMode >::pair(std::string,mvIMPACT::acquire::TAutoControlMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoControlMode >::pair(std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTAutoControlMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoControlMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoControlMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTAutoControlMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTAutoControlMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoControlMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoControlMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoControlMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  mvIMPACT::acquire::TAutoControlMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoControlMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoControlMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTAutoControlMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoControlMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoControlMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoControlMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoControlMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TAutoControlMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTAutoControlMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTAutoControlMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTAutoControlMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTAutoControlMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIAutoExposureControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoExposureControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIAutoExposureControl" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoExposureControl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIAutoExposureControl" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIAutoExposureControl" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoExposureControl(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIAutoExposureControl", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIAutoExposureControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIAutoExposureControl__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIAutoExposureControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIAutoExposureControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoExposureControl_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TAutoExposureControl> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoExposureControl> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoExposureControl> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TAutoExposureControl>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TAutoExposureControl>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoExposureControl_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoExposureControl_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoExposureControl_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoExposureControl result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoExposureControl_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoExposureControl result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoExposureControl_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoExposureControl_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoExposureControl_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoExposureControl_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoExposureControl result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoExposureControl_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoExposureControl result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoExposureControl result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoExposureControl result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoExposureControl result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoExposureControl_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoExposureControl_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoExposureControl_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoExposureControl_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoExposureControl_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIAutoExposureControl_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoExposureControl_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoExposureControl_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoExposureControl_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoExposureControl_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIAutoExposureControl_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoExposureControl_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoExposureControl_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoExposureControl_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::read(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::read(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::read(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::read(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::read(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::read(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  mvIMPACT::acquire::TAutoExposureControl arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoExposureControl_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoExposureControl""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoExposureControl >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoExposureControl_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  mvIMPACT::acquire::TAutoExposureControl arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoExposureControl_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoExposureControl""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoExposureControl >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoExposureControl_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoExposureControl_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoExposureControl_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoExposureControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoExposureControl >* pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoExposureControl_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoExposureControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoExposureControl>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoExposureControl_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoExposureControl_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoExposureControl_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoExposureControl_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoExposureControl_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::write(mvIMPACT::acquire::TAutoExposureControl,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::write(mvIMPACT::acquire::TAutoExposureControl) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::write(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::write(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::write(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >::write(std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIAutoExposureControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIAutoExposureControl" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIAutoExposureControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIAutoExposureControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTAutoExposureControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *)new std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoExposureControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TAutoExposureControl arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTAutoExposureControl" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTAutoExposureControl" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoExposureControl""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoExposureControl >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *)new std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoExposureControl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *ptr = (std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTAutoExposureControl" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTAutoExposureControl" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *)new std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl >((std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoExposureControl(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTAutoExposureControl", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTAutoExposureControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTAutoExposureControl__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTAutoExposureControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTAutoExposureControl'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl >::pair(std::string,mvIMPACT::acquire::TAutoExposureControl)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl >::pair(std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTAutoExposureControl_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoExposureControl_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoExposureControl_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTAutoExposureControl_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTAutoExposureControl_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoExposureControl_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoExposureControl_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoExposureControl_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  mvIMPACT::acquire::TAutoExposureControl arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoExposureControl_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoExposureControl_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTAutoExposureControl_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoExposureControl""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoExposureControl >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoExposureControl_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoExposureControl result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoExposureControl_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TAutoExposureControl) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTAutoExposureControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTAutoExposureControl" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTAutoExposureControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTAutoExposureControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIAutoGainControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoGainControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIAutoGainControl" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoGainControl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIAutoGainControl" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIAutoGainControl" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoGainControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIAutoGainControl", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIAutoGainControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIAutoGainControl__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIAutoGainControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIAutoGainControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoGainControl_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TAutoGainControl> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoGainControl> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoGainControl> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TAutoGainControl>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TAutoGainControl>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoGainControl_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoGainControl_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIAutoGainControl_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoGainControl_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoGainControl result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoGainControl_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoGainControl result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoGainControl_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIAutoGainControl_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoGainControl_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoGainControl_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoGainControl_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoGainControl result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoGainControl_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoGainControl result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoGainControl result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoGainControl result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoGainControl result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoGainControl_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoGainControl_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoGainControl_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoGainControl_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoGainControl_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIAutoGainControl_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoGainControl_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoGainControl_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoGainControl_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoGainControl_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoGainControl_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoGainControl_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIAutoGainControl_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoGainControl_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::read(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::read(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::read(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::read(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::read(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::read(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  mvIMPACT::acquire::TAutoGainControl arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoGainControl_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoGainControl""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoGainControl >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoGainControl_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  mvIMPACT::acquire::TAutoGainControl arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoGainControl_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoGainControl""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoGainControl >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoGainControl_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoGainControl_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoGainControl_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoGainControl_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoGainControl >* pV = new std::vector<mvIMPACT::acquire::TAutoGainControl > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoGainControl_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoGainControl >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoGainControl>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoGainControl_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoGainControl_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoGainControl_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIAutoGainControl_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoGainControl_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoGainControl_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::write(mvIMPACT::acquire::TAutoGainControl,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::write(mvIMPACT::acquire::TAutoGainControl) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::write(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::write(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::write(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >::write(std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIAutoGainControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIAutoGainControl" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIAutoGainControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIAutoGainControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTAutoGainControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *)new std::pair< std::string,mvIMPACT::acquire::TAutoGainControl >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoGainControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TAutoGainControl arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTAutoGainControl" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTAutoGainControl" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoGainControl""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoGainControl >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *)new std::pair< std::string,mvIMPACT::acquire::TAutoGainControl >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoGainControl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *ptr = (std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTAutoGainControl" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTAutoGainControl" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *)new std::pair< std::string,mvIMPACT::acquire::TAutoGainControl >((std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoGainControl(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTAutoGainControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTAutoGainControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTAutoGainControl__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTAutoGainControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTAutoGainControl'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TAutoGainControl >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoGainControl >::pair(std::string,mvIMPACT::acquire::TAutoGainControl)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoGainControl >::pair(std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTAutoGainControl_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoGainControl_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoGainControl_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTAutoGainControl_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTAutoGainControl_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoGainControl_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoGainControl_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoGainControl_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  mvIMPACT::acquire::TAutoGainControl arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoGainControl_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoGainControl_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTAutoGainControl_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoGainControl""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoGainControl >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoGainControl_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoGainControl result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoGainControl_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TAutoGainControl) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTAutoGainControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTAutoGainControl" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTAutoGainControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTAutoGainControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIAutoOffsetCalibration__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoOffsetCalibration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIAutoOffsetCalibration" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoOffsetCalibration__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIAutoOffsetCalibration" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIAutoOffsetCalibration" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIAutoOffsetCalibration(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIAutoOffsetCalibration", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIAutoOffsetCalibration__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIAutoOffsetCalibration__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIAutoOffsetCalibration__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIAutoOffsetCalibration'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoOffsetCalibration_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TAutoOffsetCalibration> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoOffsetCalibration> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TAutoOffsetCalibration> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TAutoOffsetCalibration>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TAutoOffsetCalibration>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoOffsetCalibration_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoOffsetCalibration_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoOffsetCalibration result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoOffsetCalibration result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoOffsetCalibration_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoOffsetCalibration_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoOffsetCalibration_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIAutoOffsetCalibration_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TAutoOffsetCalibration result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TAutoOffsetCalibration result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoOffsetCalibration result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoOffsetCalibration result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoOffsetCalibration result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoOffsetCalibration_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoOffsetCalibration_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoOffsetCalibration_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::read(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::read(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::read(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::read(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::read(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::read(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  mvIMPACT::acquire::TAutoOffsetCalibration arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoOffsetCalibration""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoOffsetCalibration >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  mvIMPACT::acquire::TAutoOffsetCalibration arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoOffsetCalibration""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoOffsetCalibration >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >* pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIAutoOffsetCalibration_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TAutoOffsetCalibration >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TAutoOffsetCalibration>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIAutoOffsetCalibration_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoOffsetCalibration_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoOffsetCalibration_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIAutoOffsetCalibration_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIAutoOffsetCalibration_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::write(mvIMPACT::acquire::TAutoOffsetCalibration,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::write(mvIMPACT::acquire::TAutoOffsetCalibration) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::write(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::write(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::write(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >::write(std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIAutoOffsetCalibration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIAutoOffsetCalibration" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIAutoOffsetCalibration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIAutoOffsetCalibration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTAutoOffsetCalibration__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *)new std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoOffsetCalibration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TAutoOffsetCalibration arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTAutoOffsetCalibration" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTAutoOffsetCalibration" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoOffsetCalibration""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoOffsetCalibration >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *)new std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoOffsetCalibration__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *ptr = (std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTAutoOffsetCalibration" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTAutoOffsetCalibration" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *)new std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration >((std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTAutoOffsetCalibration(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTAutoOffsetCalibration", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTAutoOffsetCalibration__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTAutoOffsetCalibration__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTAutoOffsetCalibration__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTAutoOffsetCalibration'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration >::pair(std::string,mvIMPACT::acquire::TAutoOffsetCalibration)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration >::pair(std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTAutoOffsetCalibration_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoOffsetCalibration_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoOffsetCalibration_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTAutoOffsetCalibration_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTAutoOffsetCalibration_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoOffsetCalibration_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoOffsetCalibration_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoOffsetCalibration_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  mvIMPACT::acquire::TAutoOffsetCalibration arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTAutoOffsetCalibration_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoOffsetCalibration_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTAutoOffsetCalibration_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TAutoOffsetCalibration""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TAutoOffsetCalibration >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTAutoOffsetCalibration_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TAutoOffsetCalibration result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTAutoOffsetCalibration_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TAutoOffsetCalibration) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTAutoOffsetCalibration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTAutoOffsetCalibration" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTAutoOffsetCalibration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTAutoOffsetCalibration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBayerConversionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBayerConversionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBayerConversionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBayerConversionMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBayerConversionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBayerConversionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBayerConversionMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBayerConversionMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIBayerConversionMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIBayerConversionMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIBayerConversionMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBayerConversionMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBayerConversionMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBayerConversionMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBayerConversionMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBayerConversionMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBayerConversionMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBayerConversionMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerConversionMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerConversionMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerConversionMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBayerConversionMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerConversionMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBayerConversionMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerConversionMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerConversionMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBayerConversionMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBayerConversionMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBayerConversionMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerConversionMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBayerConversionMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerConversionMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerConversionMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerConversionMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerConversionMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerConversionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerConversionMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerConversionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerConversionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBayerConversionMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerConversionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerConversionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerConversionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerConversionMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBayerConversionMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBayerConversionMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBayerConversionMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerConversionMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::read(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::read(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::read(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::read(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::read(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::read(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  mvIMPACT::acquire::TBayerConversionMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerConversionMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerConversionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerConversionMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerConversionMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  mvIMPACT::acquire::TBayerConversionMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerConversionMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerConversionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerConversionMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerConversionMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerConversionMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerConversionMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerConversionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerConversionMode >* pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerConversionMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerConversionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerConversionMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerConversionMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBayerConversionMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBayerConversionMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBayerConversionMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerConversionMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::write(mvIMPACT::acquire::TBayerConversionMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::write(mvIMPACT::acquire::TBayerConversionMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::write(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::write(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::write(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >::write(std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBayerConversionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBayerConversionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBayerConversionMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBayerConversionMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBayerConversionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *)new std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBayerConversionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBayerConversionMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBayerConversionMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBayerConversionMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerConversionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerConversionMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *)new std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBayerConversionMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBayerConversionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBayerConversionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *)new std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode >((std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBayerConversionMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBayerConversionMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBayerConversionMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBayerConversionMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBayerConversionMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBayerConversionMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode >::pair(std::string,mvIMPACT::acquire::TBayerConversionMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode >::pair(std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBayerConversionMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBayerConversionMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerConversionMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBayerConversionMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBayerConversionMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBayerConversionMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerConversionMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBayerConversionMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  mvIMPACT::acquire::TBayerConversionMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBayerConversionMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerConversionMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBayerConversionMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerConversionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerConversionMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBayerConversionMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerConversionMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerConversionMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBayerConversionMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBayerConversionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBayerConversionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBayerConversionMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBayerConversionMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBayerMosaicParity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBayerMosaicParity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBayerMosaicParity" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBayerMosaicParity__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBayerMosaicParity" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBayerMosaicParity" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBayerMosaicParity(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBayerMosaicParity", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIBayerMosaicParity__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIBayerMosaicParity__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIBayerMosaicParity__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBayerMosaicParity'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBayerMosaicParity_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBayerMosaicParity> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBayerMosaicParity> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBayerMosaicParity> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBayerMosaicParity>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBayerMosaicParity>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerMosaicParity_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerMosaicParity_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerMosaicParity_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBayerMosaicParity result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerMosaicParity_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBayerMosaicParity result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerMosaicParity_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerMosaicParity_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBayerMosaicParity_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBayerMosaicParity_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBayerMosaicParity result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBayerMosaicParity result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerMosaicParity result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerMosaicParity result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerMosaicParity result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerMosaicParity_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerMosaicParity_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBayerMosaicParity_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerMosaicParity_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::read(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::read(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::read(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::read(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::read(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::read(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  mvIMPACT::acquire::TBayerMosaicParity arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerMosaicParity""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerMosaicParity >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  mvIMPACT::acquire::TBayerMosaicParity arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerMosaicParity""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerMosaicParity >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerMosaicParity >* pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerMosaicParity_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerMosaicParity >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerMosaicParity>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerMosaicParity_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBayerMosaicParity_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBayerMosaicParity_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBayerMosaicParity_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerMosaicParity_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::write(mvIMPACT::acquire::TBayerMosaicParity,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::write(mvIMPACT::acquire::TBayerMosaicParity) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::write(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::write(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::write(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >::write(std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBayerMosaicParity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBayerMosaicParity" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBayerMosaicParity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBayerMosaicParity_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBayerMosaicParity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *)new std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBayerMosaicParity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBayerMosaicParity arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBayerMosaicParity" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBayerMosaicParity" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerMosaicParity""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerMosaicParity >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *)new std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBayerMosaicParity__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBayerMosaicParity" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBayerMosaicParity" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *)new std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity >((std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBayerMosaicParity(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBayerMosaicParity", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBayerMosaicParity__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBayerMosaicParity__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBayerMosaicParity__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBayerMosaicParity'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity >::pair(std::string,mvIMPACT::acquire::TBayerMosaicParity)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity >::pair(std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBayerMosaicParity_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBayerMosaicParity_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerMosaicParity_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBayerMosaicParity_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBayerMosaicParity_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBayerMosaicParity_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerMosaicParity_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBayerMosaicParity_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  mvIMPACT::acquire::TBayerMosaicParity arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBayerMosaicParity_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerMosaicParity_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBayerMosaicParity_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerMosaicParity""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerMosaicParity >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBayerMosaicParity_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerMosaicParity result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerMosaicParity_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBayerMosaicParity) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBayerMosaicParity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBayerMosaicParity" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBayerMosaicParity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBayerMosaicParity_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBayerWhiteBalanceResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBayerWhiteBalanceResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBayerWhiteBalanceResult" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBayerWhiteBalanceResult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBayerWhiteBalanceResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBayerWhiteBalanceResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBayerWhiteBalanceResult(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBayerWhiteBalanceResult", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIBayerWhiteBalanceResult__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIBayerWhiteBalanceResult__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIBayerWhiteBalanceResult__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBayerWhiteBalanceResult'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBayerWhiteBalanceResult_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBayerWhiteBalanceResult> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBayerWhiteBalanceResult> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBayerWhiteBalanceResult> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBayerWhiteBalanceResult>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBayerWhiteBalanceResult>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerWhiteBalanceResult_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerWhiteBalanceResult_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBayerWhiteBalanceResult result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBayerWhiteBalanceResult result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerWhiteBalanceResult_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerWhiteBalanceResult_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBayerWhiteBalanceResult_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBayerWhiteBalanceResult_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBayerWhiteBalanceResult result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBayerWhiteBalanceResult result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerWhiteBalanceResult result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerWhiteBalanceResult result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerWhiteBalanceResult result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerWhiteBalanceResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerWhiteBalanceResult_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerWhiteBalanceResult_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::read(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::read(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::read(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::read(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::read(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::read(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  mvIMPACT::acquire::TBayerWhiteBalanceResult arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerWhiteBalanceResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerWhiteBalanceResult >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  mvIMPACT::acquire::TBayerWhiteBalanceResult arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerWhiteBalanceResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerWhiteBalanceResult >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >* pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBayerWhiteBalanceResult_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBayerWhiteBalanceResult>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBayerWhiteBalanceResult_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBayerWhiteBalanceResult_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::write(mvIMPACT::acquire::TBayerWhiteBalanceResult,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::write(mvIMPACT::acquire::TBayerWhiteBalanceResult) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::write(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::write(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::write(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >::write(std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBayerWhiteBalanceResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBayerWhiteBalanceResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBayerWhiteBalanceResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBayerWhiteBalanceResult_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBayerWhiteBalanceResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *)new std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBayerWhiteBalanceResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBayerWhiteBalanceResult arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  { std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBayerWhiteBalanceResult" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBayerWhiteBalanceResult" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerWhiteBalanceResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerWhiteBalanceResult >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *)new std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBayerWhiteBalanceResult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBayerWhiteBalanceResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBayerWhiteBalanceResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *)new std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult >((std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBayerWhiteBalanceResult(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBayerWhiteBalanceResult", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBayerWhiteBalanceResult__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBayerWhiteBalanceResult__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBayerWhiteBalanceResult__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBayerWhiteBalanceResult'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult >::pair(std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult >::pair(std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBayerWhiteBalanceResult_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBayerWhiteBalanceResult_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerWhiteBalanceResult_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBayerWhiteBalanceResult_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBayerWhiteBalanceResult_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBayerWhiteBalanceResult_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerWhiteBalanceResult_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBayerWhiteBalanceResult_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  mvIMPACT::acquire::TBayerWhiteBalanceResult arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBayerWhiteBalanceResult_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerWhiteBalanceResult_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBayerWhiteBalanceResult_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBayerWhiteBalanceResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBayerWhiteBalanceResult >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBayerWhiteBalanceResult_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBayerWhiteBalanceResult result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBayerWhiteBalanceResult_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBayerWhiteBalanceResult) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBayerWhiteBalanceResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBayerWhiteBalanceResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBayerWhiteBalanceResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBayerWhiteBalanceResult_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXDigitalInputThreshold__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXDigitalInputThreshold__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBlueFOXDigitalInputThreshold" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXDigitalInputThreshold__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBlueFOXDigitalInputThreshold" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBlueFOXDigitalInputThreshold" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXDigitalInputThreshold(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBlueFOXDigitalInputThreshold", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIBlueFOXDigitalInputThreshold__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIBlueFOXDigitalInputThreshold__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIBlueFOXDigitalInputThreshold__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBlueFOXDigitalInputThreshold'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXDigitalInputThreshold_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TBlueFOXDigitalInputThreshold result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXDigitalInputThreshold result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TBlueFOXDigitalInputThreshold result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXDigitalInputThreshold result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXDigitalInputThreshold result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXDigitalInputThreshold result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXDigitalInputThreshold result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXDigitalInputThreshold_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXDigitalInputThreshold_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXDigitalInputThreshold_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::read(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::read(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::read(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::read(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::read(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::read(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  mvIMPACT::acquire::TBlueFOXDigitalInputThreshold arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXDigitalInputThreshold""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  mvIMPACT::acquire::TBlueFOXDigitalInputThreshold arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXDigitalInputThreshold""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXDigitalInputThreshold_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXDigitalInputThreshold_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXDigitalInputThreshold_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::write(mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::write(mvIMPACT::acquire::TBlueFOXDigitalInputThreshold) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::write(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::write(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::write(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::write(std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBlueFOXDigitalInputThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBlueFOXDigitalInputThreshold" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBlueFOXDigitalInputThreshold_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBlueFOXDigitalInputThreshold_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXDigitalInputThreshold__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXDigitalInputThreshold__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBlueFOXDigitalInputThreshold arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBlueFOXDigitalInputThreshold" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBlueFOXDigitalInputThreshold" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXDigitalInputThreshold""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXDigitalInputThreshold__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBlueFOXDigitalInputThreshold" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBlueFOXDigitalInputThreshold" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >((std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXDigitalInputThreshold(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBlueFOXDigitalInputThreshold", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBlueFOXDigitalInputThreshold__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXDigitalInputThreshold__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXDigitalInputThreshold__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBlueFOXDigitalInputThreshold'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::pair(std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >::pair(std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXDigitalInputThreshold_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXDigitalInputThreshold_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXDigitalInputThreshold_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBlueFOXDigitalInputThreshold_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBlueFOXDigitalInputThreshold_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXDigitalInputThreshold_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXDigitalInputThreshold_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXDigitalInputThreshold_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  mvIMPACT::acquire::TBlueFOXDigitalInputThreshold arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXDigitalInputThreshold_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXDigitalInputThreshold_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBlueFOXDigitalInputThreshold_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXDigitalInputThreshold""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXDigitalInputThreshold_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXDigitalInputThreshold result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXDigitalInputThreshold_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBlueFOXDigitalInputThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBlueFOXDigitalInputThreshold" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBlueFOXDigitalInputThreshold_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBlueFOXDigitalInputThreshold_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXFooterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXFooterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBlueFOXFooterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXFooterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBlueFOXFooterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBlueFOXFooterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXFooterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBlueFOXFooterMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIBlueFOXFooterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIBlueFOXFooterMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIBlueFOXFooterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBlueFOXFooterMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXFooterMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBlueFOXFooterMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXFooterMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXFooterMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBlueFOXFooterMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBlueFOXFooterMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXFooterMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXFooterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBlueFOXFooterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXFooterMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXFooterMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXFooterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXFooterMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXFooterMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBlueFOXFooterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXFooterMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXFooterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXFooterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXFooterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXFooterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXFooterMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXFooterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::read(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::read(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::read(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::read(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::read(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::read(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  mvIMPACT::acquire::TBlueFOXFooterMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXFooterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXFooterMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  mvIMPACT::acquire::TBlueFOXFooterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXFooterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXFooterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXFooterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXFooterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXFooterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXFooterMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXFooterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXFooterMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXFooterMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXFooterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::write(mvIMPACT::acquire::TBlueFOXFooterMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::write(mvIMPACT::acquire::TBlueFOXFooterMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::write(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::write(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::write(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >::write(std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBlueFOXFooterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBlueFOXFooterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBlueFOXFooterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBlueFOXFooterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXFooterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXFooterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBlueFOXFooterMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBlueFOXFooterMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBlueFOXFooterMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXFooterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXFooterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXFooterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBlueFOXFooterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBlueFOXFooterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode >((std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXFooterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBlueFOXFooterMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBlueFOXFooterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXFooterMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXFooterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBlueFOXFooterMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode >::pair(std::string,mvIMPACT::acquire::TBlueFOXFooterMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode >::pair(std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXFooterMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXFooterMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXFooterMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBlueFOXFooterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBlueFOXFooterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXFooterMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXFooterMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXFooterMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  mvIMPACT::acquire::TBlueFOXFooterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXFooterMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXFooterMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBlueFOXFooterMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXFooterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXFooterMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXFooterMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXFooterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXFooterMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBlueFOXFooterMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBlueFOXFooterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBlueFOXFooterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBlueFOXFooterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBlueFOXFooterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXInfoSensorCapabilities__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXInfoSensorCapabilities__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBlueFOXInfoSensorCapabilities" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXInfoSensorCapabilities__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBlueFOXInfoSensorCapabilities" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBlueFOXInfoSensorCapabilities" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXInfoSensorCapabilities(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBlueFOXInfoSensorCapabilities", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIBlueFOXInfoSensorCapabilities__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIBlueFOXInfoSensorCapabilities__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIBlueFOXInfoSensorCapabilities__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBlueFOXInfoSensorCapabilities'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXInfoSensorCapabilities_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXInfoSensorCapabilities_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::read(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::read(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::read(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::read(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::read(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::read(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXInfoSensorCapabilities_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXInfoSensorCapabilities_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::write(mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::write(mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::write(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::write(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::write(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::write(std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBlueFOXInfoSensorCapabilities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBlueFOXInfoSensorCapabilities" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBlueFOXInfoSensorCapabilities_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBlueFOXInfoSensorCapabilities_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXInfoSensorCapabilities__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXInfoSensorCapabilities__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBlueFOXInfoSensorCapabilities" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBlueFOXInfoSensorCapabilities" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXInfoSensorCapabilities__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBlueFOXInfoSensorCapabilities" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBlueFOXInfoSensorCapabilities" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >((std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXInfoSensorCapabilities(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBlueFOXInfoSensorCapabilities", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBlueFOXInfoSensorCapabilities__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXInfoSensorCapabilities__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXInfoSensorCapabilities__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBlueFOXInfoSensorCapabilities'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::pair(std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >::pair(std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXInfoSensorCapabilities_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXInfoSensorCapabilities_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXInfoSensorCapabilities_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBlueFOXInfoSensorCapabilities_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBlueFOXInfoSensorCapabilities_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXInfoSensorCapabilities_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXInfoSensorCapabilities_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXInfoSensorCapabilities_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXInfoSensorCapabilities_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXInfoSensorCapabilities_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBlueFOXInfoSensorCapabilities_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXInfoSensorCapabilities_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXInfoSensorCapabilities_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBlueFOXInfoSensorCapabilities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBlueFOXInfoSensorCapabilities" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBlueFOXInfoSensorCapabilities_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBlueFOXInfoSensorCapabilities_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBlueFOXOffsetAutoBlackSpeed" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBlueFOXOffsetAutoBlackSpeed" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBlueFOXOffsetAutoBlackSpeed" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBlueFOXOffsetAutoBlackSpeed", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBlueFOXOffsetAutoBlackSpeed'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXOffsetAutoBlackSpeed_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXOffsetAutoBlackSpeed_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::read(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::read(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::read(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::read(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::read(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::read(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXOffsetAutoBlackSpeed_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXOffsetAutoBlackSpeed_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::write(mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::write(mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::write(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::write(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::write(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::write(std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBlueFOXOffsetAutoBlackSpeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBlueFOXOffsetAutoBlackSpeed" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBlueFOXOffsetAutoBlackSpeed_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBlueFOXOffsetAutoBlackSpeed_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXOffsetAutoBlackSpeed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXOffsetAutoBlackSpeed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBlueFOXOffsetAutoBlackSpeed" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBlueFOXOffsetAutoBlackSpeed" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXOffsetAutoBlackSpeed__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBlueFOXOffsetAutoBlackSpeed" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBlueFOXOffsetAutoBlackSpeed" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >((std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXOffsetAutoBlackSpeed(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBlueFOXOffsetAutoBlackSpeed", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBlueFOXOffsetAutoBlackSpeed__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXOffsetAutoBlackSpeed__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXOffsetAutoBlackSpeed__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBlueFOXOffsetAutoBlackSpeed'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::pair(std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >::pair(std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXOffsetAutoBlackSpeed_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXOffsetAutoBlackSpeed_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXOffsetAutoBlackSpeed_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBlueFOXOffsetAutoBlackSpeed_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBlueFOXOffsetAutoBlackSpeed_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXOffsetAutoBlackSpeed_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXOffsetAutoBlackSpeed_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXOffsetAutoBlackSpeed_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXOffsetAutoBlackSpeed_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXOffsetAutoBlackSpeed_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBlueFOXOffsetAutoBlackSpeed_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXOffsetAutoBlackSpeed_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXOffsetAutoBlackSpeed_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBlueFOXOffsetAutoBlackSpeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBlueFOXOffsetAutoBlackSpeed" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBlueFOXOffsetAutoBlackSpeed_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBlueFOXOffsetAutoBlackSpeed_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXSensorTiming__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXSensorTiming__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBlueFOXSensorTiming" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXSensorTiming__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBlueFOXSensorTiming" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBlueFOXSensorTiming" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXSensorTiming(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBlueFOXSensorTiming", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIBlueFOXSensorTiming__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIBlueFOXSensorTiming__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIBlueFOXSensorTiming__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBlueFOXSensorTiming'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXSensorTiming_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBlueFOXSensorTiming> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXSensorTiming> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXSensorTiming> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBlueFOXSensorTiming>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBlueFOXSensorTiming>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXSensorTiming_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXSensorTiming_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBlueFOXSensorTiming result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXSensorTiming result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXSensorTiming_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXSensorTiming_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXSensorTiming_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXSensorTiming_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBlueFOXSensorTiming result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXSensorTiming result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXSensorTiming result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXSensorTiming result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXSensorTiming result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXSensorTiming_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXSensorTiming_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXSensorTiming_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::read(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::read(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::read(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::read(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::read(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::read(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  mvIMPACT::acquire::TBlueFOXSensorTiming arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXSensorTiming""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXSensorTiming >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  mvIMPACT::acquire::TBlueFOXSensorTiming arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXSensorTiming""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXSensorTiming >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXSensorTiming_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXSensorTiming>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXSensorTiming_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXSensorTiming_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::write(mvIMPACT::acquire::TBlueFOXSensorTiming,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::write(mvIMPACT::acquire::TBlueFOXSensorTiming) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::write(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::write(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::write(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >::write(std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBlueFOXSensorTiming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBlueFOXSensorTiming" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBlueFOXSensorTiming_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBlueFOXSensorTiming_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXSensorTiming__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXSensorTiming__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBlueFOXSensorTiming arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBlueFOXSensorTiming" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBlueFOXSensorTiming" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXSensorTiming""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXSensorTiming >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXSensorTiming__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBlueFOXSensorTiming" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBlueFOXSensorTiming" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming >((std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXSensorTiming(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBlueFOXSensorTiming", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBlueFOXSensorTiming__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXSensorTiming__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXSensorTiming__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBlueFOXSensorTiming'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming >::pair(std::string,mvIMPACT::acquire::TBlueFOXSensorTiming)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming >::pair(std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXSensorTiming_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXSensorTiming_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXSensorTiming_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBlueFOXSensorTiming_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBlueFOXSensorTiming_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXSensorTiming_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXSensorTiming_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXSensorTiming_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  mvIMPACT::acquire::TBlueFOXSensorTiming arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXSensorTiming_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXSensorTiming_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBlueFOXSensorTiming_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXSensorTiming""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXSensorTiming >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXSensorTiming_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXSensorTiming result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXSensorTiming_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBlueFOXSensorTiming) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBlueFOXSensorTiming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBlueFOXSensorTiming" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBlueFOXSensorTiming_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBlueFOXSensorTiming_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXTransferSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXTransferSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBlueFOXTransferSize" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXTransferSize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBlueFOXTransferSize" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBlueFOXTransferSize" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBlueFOXTransferSize(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBlueFOXTransferSize", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIBlueFOXTransferSize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIBlueFOXTransferSize__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIBlueFOXTransferSize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBlueFOXTransferSize'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXTransferSize_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBlueFOXTransferSize> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXTransferSize> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBlueFOXTransferSize> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBlueFOXTransferSize>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBlueFOXTransferSize>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXTransferSize_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXTransferSize_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBlueFOXTransferSize result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXTransferSize result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXTransferSize_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXTransferSize_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXTransferSize_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXTransferSize_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBlueFOXTransferSize result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBlueFOXTransferSize result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXTransferSize result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXTransferSize result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXTransferSize result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXTransferSize_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXTransferSize_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXTransferSize_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::read(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::read(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::read(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::read(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::read(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::read(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  mvIMPACT::acquire::TBlueFOXTransferSize arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXTransferSize""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXTransferSize >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  mvIMPACT::acquire::TBlueFOXTransferSize arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXTransferSize""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXTransferSize >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >* pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBlueFOXTransferSize_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBlueFOXTransferSize >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBlueFOXTransferSize>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBlueFOXTransferSize_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXTransferSize_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXTransferSize_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBlueFOXTransferSize_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBlueFOXTransferSize_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::write(mvIMPACT::acquire::TBlueFOXTransferSize,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::write(mvIMPACT::acquire::TBlueFOXTransferSize) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::write(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::write(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::write(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >::write(std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBlueFOXTransferSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBlueFOXTransferSize" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBlueFOXTransferSize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBlueFOXTransferSize_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXTransferSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXTransferSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBlueFOXTransferSize arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBlueFOXTransferSize" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBlueFOXTransferSize" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXTransferSize""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXTransferSize >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXTransferSize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBlueFOXTransferSize" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBlueFOXTransferSize" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *)new std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize >((std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBlueFOXTransferSize(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBlueFOXTransferSize", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBlueFOXTransferSize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXTransferSize__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBlueFOXTransferSize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBlueFOXTransferSize'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize >::pair(std::string,mvIMPACT::acquire::TBlueFOXTransferSize)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize >::pair(std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXTransferSize_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXTransferSize_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXTransferSize_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBlueFOXTransferSize_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBlueFOXTransferSize_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXTransferSize_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXTransferSize_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXTransferSize_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  mvIMPACT::acquire::TBlueFOXTransferSize arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBlueFOXTransferSize_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXTransferSize_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBlueFOXTransferSize_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBlueFOXTransferSize""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBlueFOXTransferSize >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBlueFOXTransferSize_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBlueFOXTransferSize result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBlueFOXTransferSize_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBlueFOXTransferSize) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBlueFOXTransferSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBlueFOXTransferSize" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBlueFOXTransferSize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBlueFOXTransferSize_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIBoolean__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBoolean__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIBoolean" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBoolean__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIBoolean" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIBoolean" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIBoolean(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIBoolean", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIBoolean__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIBoolean__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIBoolean__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIBoolean'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBoolean >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBoolean > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBoolean_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBoolean> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBoolean> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBoolean> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBoolean>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBoolean>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBoolean_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBoolean_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBoolean_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBoolean_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBoolean_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBoolean result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBoolean_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBoolean result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBoolean_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIBoolean_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBoolean_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBoolean_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBoolean_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIBoolean_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBoolean result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBoolean_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBoolean result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBoolean result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBoolean result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBoolean result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; int arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBoolean_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBoolean_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBoolean_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; bool arg3 ; int arg4 ;
  int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBoolean_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBoolean_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIBoolean_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; bool arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBoolean_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBoolean_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBoolean_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBoolean_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIBoolean_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBoolean_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBoolean_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBoolean_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBoolean_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIBoolean_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBoolean_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIBoolean_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBoolean_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::read(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::read(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::read(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::read(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::read(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::read(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  mvIMPACT::acquire::TBoolean arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBoolean_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBoolean""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBoolean >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBoolean_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  mvIMPACT::acquire::TBoolean arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIBoolean_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBoolean""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBoolean >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBoolean_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; bool arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBoolean_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIBoolean_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIBoolean_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBoolean >* pV = new std::vector<mvIMPACT::acquire::TBoolean > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIBoolean_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBoolean >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBoolean>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIBoolean_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBoolean_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIBoolean_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIBoolean_write__SWIG_5(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIBoolean_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIBoolean_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIBoolean_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIBoolean_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::write(mvIMPACT::acquire::TBoolean,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::write(mvIMPACT::acquire::TBoolean) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::write(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::write(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::write(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >::write(std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIBoolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIBoolean" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIBoolean_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIBoolean_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBoolean__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBoolean > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBoolean > *)new std::pair< std::string,mvIMPACT::acquire::TBoolean >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBoolean__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBoolean arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TBoolean > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBoolean" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBoolean" "', argument " "2"" of type '" "mvIMPACT::acquire::TBoolean""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBoolean >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBoolean > *)new std::pair< std::string,mvIMPACT::acquire::TBoolean >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBoolean__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBoolean > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TBoolean > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBoolean > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBoolean > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBoolean" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBoolean > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBoolean" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBoolean > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBoolean > *)new std::pair< std::string,mvIMPACT::acquire::TBoolean >((std::pair< std::string,mvIMPACT::acquire::TBoolean > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBoolean(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBoolean", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTBoolean__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBoolean__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBoolean__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBoolean'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBoolean >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBoolean >::pair(std::string,mvIMPACT::acquire::TBoolean)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBoolean >::pair(std::pair< std::string,mvIMPACT::acquire::TBoolean > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBoolean_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBoolean > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBoolean > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBoolean_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBoolean_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBoolean > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBoolean > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBoolean_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBoolean_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBoolean_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBoolean > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBoolean_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBoolean > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBoolean > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBoolean_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBoolean > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBoolean > *) 0 ;
  mvIMPACT::acquire::TBoolean arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBoolean_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBoolean_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBoolean > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBoolean > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBoolean_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBoolean""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBoolean >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->second = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBoolean_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBoolean > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBoolean result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBoolean_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBoolean > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBoolean > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::TBoolean) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBoolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBoolean > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBoolean > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBoolean" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBoolean > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBoolean > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBoolean_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBoolean_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraAoiMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraAoiMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraAoiMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraAoiMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraAoiMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraAoiMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraAoiMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraAoiMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyICameraAoiMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraAoiMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraAoiMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraAoiMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraAoiMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraAoiMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraAoiMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraAoiMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraAoiMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraAoiMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraAoiMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraAoiMode_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraAoiMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraAoiMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraAoiMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraAoiMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraAoiMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraAoiMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraAoiMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraAoiMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraAoiMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraAoiMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraAoiMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraAoiMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraAoiMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraAoiMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraAoiMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraAoiMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraAoiMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraAoiMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraAoiMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraAoiMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraAoiMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraAoiMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraAoiMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraAoiMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraAoiMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraAoiMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraAoiMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraAoiMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraAoiMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraAoiMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraAoiMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraAoiMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraAoiMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraAoiMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraAoiMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraAoiMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraAoiMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::read(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::read(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::read(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::read(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::read(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::read(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  mvIMPACT::acquire::TCameraAoiMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraAoiMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraAoiMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraAoiMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraAoiMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  mvIMPACT::acquire::TCameraAoiMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraAoiMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraAoiMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraAoiMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraAoiMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraAoiMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraAoiMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraAoiMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraAoiMode >* pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraAoiMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraAoiMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraAoiMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraAoiMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraAoiMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraAoiMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraAoiMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraAoiMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraAoiMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraAoiMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraAoiMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::write(mvIMPACT::acquire::TCameraAoiMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::write(mvIMPACT::acquire::TCameraAoiMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::write(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::write(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::write(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >::write(std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraAoiMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraAoiMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraAoiMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraAoiMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraAoiMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraAoiMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraAoiMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraAoiMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraAoiMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraAoiMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraAoiMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraAoiMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraAoiMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraAoiMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode >((std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraAoiMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraAoiMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraAoiMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraAoiMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraAoiMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraAoiMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode >::pair(std::string,mvIMPACT::acquire::TCameraAoiMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraAoiMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraAoiMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraAoiMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraAoiMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraAoiMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraAoiMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraAoiMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraAoiMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  mvIMPACT::acquire::TCameraAoiMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraAoiMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraAoiMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraAoiMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraAoiMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraAoiMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraAoiMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraAoiMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraAoiMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraAoiMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraAoiMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraAoiMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraAoiMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraAoiMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraBinningMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraBinningMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraBinningMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraBinningMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraBinningMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraBinningMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraBinningMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraBinningMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyICameraBinningMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraBinningMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraBinningMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraBinningMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraBinningMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraBinningMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraBinningMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraBinningMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraBinningMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraBinningMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraBinningMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraBinningMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraBinningMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraBinningMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraBinningMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraBinningMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraBinningMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraBinningMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraBinningMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraBinningMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraBinningMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraBinningMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraBinningMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraBinningMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraBinningMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraBinningMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraBinningMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraBinningMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraBinningMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraBinningMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraBinningMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraBinningMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraBinningMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraBinningMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraBinningMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraBinningMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraBinningMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraBinningMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraBinningMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraBinningMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraBinningMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::read(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::read(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::read(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::read(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::read(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::read(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  mvIMPACT::acquire::TCameraBinningMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraBinningMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraBinningMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraBinningMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraBinningMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  mvIMPACT::acquire::TCameraBinningMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraBinningMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraBinningMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraBinningMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraBinningMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraBinningMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraBinningMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraBinningMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraBinningMode >* pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraBinningMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraBinningMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraBinningMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraBinningMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraBinningMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraBinningMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraBinningMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraBinningMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraBinningMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::write(mvIMPACT::acquire::TCameraBinningMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::write(mvIMPACT::acquire::TCameraBinningMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::write(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::write(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::write(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >::write(std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraBinningMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraBinningMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraBinningMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraBinningMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraBinningMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraBinningMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraBinningMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraBinningMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraBinningMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraBinningMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraBinningMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraBinningMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraBinningMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraBinningMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode >((std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraBinningMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraBinningMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraBinningMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraBinningMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraBinningMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraBinningMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode >::pair(std::string,mvIMPACT::acquire::TCameraBinningMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraBinningMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraBinningMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraBinningMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraBinningMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraBinningMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraBinningMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraBinningMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraBinningMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  mvIMPACT::acquire::TCameraBinningMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraBinningMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraBinningMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraBinningMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraBinningMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraBinningMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraBinningMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraBinningMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraBinningMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraBinningMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraBinningMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraBinningMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraBinningMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraBinningMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraDataFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraDataFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraDataFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraDataFormat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraDataFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraDataFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraDataFormat(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraDataFormat", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyICameraDataFormat__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraDataFormat__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraDataFormat__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraDataFormat'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraDataFormat_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraDataFormat> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraDataFormat> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraDataFormat> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraDataFormat>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraDataFormat>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraDataFormat_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraDataFormat_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraDataFormat_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraDataFormat result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraDataFormat_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraDataFormat result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraDataFormat_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraDataFormat_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraDataFormat_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraDataFormat_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraDataFormat_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraDataFormat result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraDataFormat_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraDataFormat result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraDataFormat result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraDataFormat result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraDataFormat result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraDataFormat_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraDataFormat_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraDataFormat_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraDataFormat_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraDataFormat_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraDataFormat_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraDataFormat_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraDataFormat_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraDataFormat_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraDataFormat_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraDataFormat_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraDataFormat_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraDataFormat_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraDataFormat_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::read(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::read(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::read(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::read(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::read(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::read(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  mvIMPACT::acquire::TCameraDataFormat arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraDataFormat_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraDataFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraDataFormat >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraDataFormat_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  mvIMPACT::acquire::TCameraDataFormat arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraDataFormat_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraDataFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraDataFormat >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraDataFormat_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraDataFormat_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraDataFormat_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraDataFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraDataFormat >* pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraDataFormat_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraDataFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraDataFormat>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraDataFormat_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraDataFormat_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraDataFormat_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraDataFormat_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraDataFormat_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraDataFormat_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::write(mvIMPACT::acquire::TCameraDataFormat,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::write(mvIMPACT::acquire::TCameraDataFormat) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::write(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::write(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::write(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >::write(std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraDataFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraDataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraDataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraDataFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *)new std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraDataFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraDataFormat arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraDataFormat" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraDataFormat" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraDataFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraDataFormat >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *)new std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraDataFormat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraDataFormat" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraDataFormat" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *)new std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat >((std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraDataFormat(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraDataFormat", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraDataFormat__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraDataFormat__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraDataFormat__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraDataFormat'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat >::pair(std::string,mvIMPACT::acquire::TCameraDataFormat)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraDataFormat_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraDataFormat_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraDataFormat_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraDataFormat_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraDataFormat_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraDataFormat_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraDataFormat_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraDataFormat_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  mvIMPACT::acquire::TCameraDataFormat arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraDataFormat_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraDataFormat_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraDataFormat_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraDataFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraDataFormat >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraDataFormat_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraDataFormat result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraDataFormat_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraDataFormat) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraDataFormat" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraDataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraDataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraExposeMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraExposeMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraExposeMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraExposeMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraExposeMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraExposeMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraExposeMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraExposeMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyICameraExposeMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraExposeMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraExposeMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraExposeMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraExposeMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraExposeMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraExposeMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraExposeMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraExposeMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraExposeMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExposeMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExposeMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExposeMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraExposeMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExposeMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraExposeMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExposeMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraExposeMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExposeMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraExposeMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraExposeMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraExposeMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExposeMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraExposeMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExposeMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExposeMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExposeMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExposeMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExposeMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExposeMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExposeMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExposeMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraExposeMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExposeMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExposeMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExposeMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExposeMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraExposeMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraExposeMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraExposeMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExposeMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::read(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::read(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::read(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::read(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::read(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::read(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  mvIMPACT::acquire::TCameraExposeMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExposeMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExposeMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExposeMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExposeMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  mvIMPACT::acquire::TCameraExposeMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExposeMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExposeMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExposeMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExposeMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExposeMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExposeMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExposeMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExposeMode >* pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExposeMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExposeMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExposeMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExposeMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraExposeMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraExposeMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraExposeMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraExposeMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExposeMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::write(mvIMPACT::acquire::TCameraExposeMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::write(mvIMPACT::acquire::TCameraExposeMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::write(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::write(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::write(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >::write(std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraExposeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraExposeMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraExposeMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraExposeMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraExposeMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraExposeMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraExposeMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraExposeMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraExposeMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExposeMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExposeMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraExposeMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraExposeMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraExposeMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode >((std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraExposeMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraExposeMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraExposeMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraExposeMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraExposeMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraExposeMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode >::pair(std::string,mvIMPACT::acquire::TCameraExposeMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExposeMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraExposeMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExposeMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraExposeMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraExposeMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExposeMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExposeMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExposeMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  mvIMPACT::acquire::TCameraExposeMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraExposeMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExposeMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraExposeMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExposeMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExposeMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExposeMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExposeMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExposeMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraExposeMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraExposeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraExposeMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraExposeMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraExposeMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraExternalSyncEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraExternalSyncEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraExternalSyncEdge" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraExternalSyncEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraExternalSyncEdge" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraExternalSyncEdge" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraExternalSyncEdge(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraExternalSyncEdge", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraExternalSyncEdge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyICameraExternalSyncEdge__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyICameraExternalSyncEdge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraExternalSyncEdge'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncEdge_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraExternalSyncEdge> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncEdge> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncEdge> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncEdge>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncEdge>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncEdge_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExternalSyncEdge_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraExternalSyncEdge result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraExternalSyncEdge result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncEdge_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExternalSyncEdge_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncEdge_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncEdge_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraExternalSyncEdge result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraExternalSyncEdge result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExternalSyncEdge result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExternalSyncEdge result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExternalSyncEdge result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncEdge_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncEdge_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExternalSyncEdge_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  mvIMPACT::acquire::TCameraExternalSyncEdge arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExternalSyncEdge""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExternalSyncEdge >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  mvIMPACT::acquire::TCameraExternalSyncEdge arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExternalSyncEdge""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExternalSyncEdge >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncEdge_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncEdge>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncEdge_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraExternalSyncEdge_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraExternalSyncEdge_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncEdge_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExternalSyncEdge_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::write(mvIMPACT::acquire::TCameraExternalSyncEdge,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::write(mvIMPACT::acquire::TCameraExternalSyncEdge) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::write(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::write(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::write(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >::write(std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraExternalSyncEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraExternalSyncEdge" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraExternalSyncEdge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraExternalSyncEdge_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraExternalSyncEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *)new std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraExternalSyncEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraExternalSyncEdge arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraExternalSyncEdge" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraExternalSyncEdge" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExternalSyncEdge""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExternalSyncEdge >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *)new std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraExternalSyncEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraExternalSyncEdge" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraExternalSyncEdge" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *)new std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge >((std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraExternalSyncEdge(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraExternalSyncEdge", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraExternalSyncEdge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraExternalSyncEdge__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraExternalSyncEdge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraExternalSyncEdge'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge >::pair(std::string,mvIMPACT::acquire::TCameraExternalSyncEdge)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExternalSyncEdge_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraExternalSyncEdge_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExternalSyncEdge_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraExternalSyncEdge_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraExternalSyncEdge_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExternalSyncEdge_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExternalSyncEdge_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExternalSyncEdge_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  mvIMPACT::acquire::TCameraExternalSyncEdge arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraExternalSyncEdge_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExternalSyncEdge_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraExternalSyncEdge_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExternalSyncEdge""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExternalSyncEdge >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExternalSyncEdge_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExternalSyncEdge result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExternalSyncEdge_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraExternalSyncEdge) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraExternalSyncEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraExternalSyncEdge" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraExternalSyncEdge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraExternalSyncEdge_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraExternalSyncOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraExternalSyncOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraExternalSyncOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraExternalSyncOutput__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraExternalSyncOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraExternalSyncOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraExternalSyncOutput(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraExternalSyncOutput", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraExternalSyncOutput__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyICameraExternalSyncOutput__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyICameraExternalSyncOutput__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraExternalSyncOutput'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncOutput_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraExternalSyncOutput> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncOutput> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncOutput> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncOutput>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraExternalSyncOutput>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncOutput_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExternalSyncOutput_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraExternalSyncOutput result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraExternalSyncOutput result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncOutput_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExternalSyncOutput_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncOutput_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncOutput_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraExternalSyncOutput result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraExternalSyncOutput result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExternalSyncOutput result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExternalSyncOutput result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExternalSyncOutput result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncOutput_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncOutput_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExternalSyncOutput_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::read(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  mvIMPACT::acquire::TCameraExternalSyncOutput arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExternalSyncOutput""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExternalSyncOutput >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  mvIMPACT::acquire::TCameraExternalSyncOutput arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExternalSyncOutput""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExternalSyncOutput >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraExternalSyncOutput_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraExternalSyncOutput>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraExternalSyncOutput_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraExternalSyncOutput_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraExternalSyncOutput_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraExternalSyncOutput_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraExternalSyncOutput_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::write(mvIMPACT::acquire::TCameraExternalSyncOutput,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::write(mvIMPACT::acquire::TCameraExternalSyncOutput) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::write(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::write(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::write(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >::write(std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraExternalSyncOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraExternalSyncOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraExternalSyncOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraExternalSyncOutput_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraExternalSyncOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *)new std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraExternalSyncOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraExternalSyncOutput arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  { std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraExternalSyncOutput" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraExternalSyncOutput" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExternalSyncOutput""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExternalSyncOutput >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *)new std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraExternalSyncOutput__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraExternalSyncOutput" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraExternalSyncOutput" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *)new std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput >((std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraExternalSyncOutput(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraExternalSyncOutput", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraExternalSyncOutput__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraExternalSyncOutput__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraExternalSyncOutput__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraExternalSyncOutput'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput >::pair(std::string,mvIMPACT::acquire::TCameraExternalSyncOutput)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExternalSyncOutput_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraExternalSyncOutput_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExternalSyncOutput_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraExternalSyncOutput_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraExternalSyncOutput_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExternalSyncOutput_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExternalSyncOutput_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExternalSyncOutput_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  mvIMPACT::acquire::TCameraExternalSyncOutput arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraExternalSyncOutput_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExternalSyncOutput_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraExternalSyncOutput_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraExternalSyncOutput""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraExternalSyncOutput >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraExternalSyncOutput_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraExternalSyncOutput result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraExternalSyncOutput_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraExternalSyncOutput) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraExternalSyncOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraExternalSyncOutput" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraExternalSyncOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraExternalSyncOutput_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraFlashMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraFlashMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraFlashMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraFlashMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraFlashMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraFlashMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraFlashMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraFlashMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraFlashMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraFlashMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraFlashMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraFlashMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraFlashMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraFlashMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraFlashMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraFlashMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraFlashMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraFlashMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraFlashMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraFlashMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraFlashMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraFlashMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraFlashMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraFlashMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraFlashMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraFlashMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraFlashMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraFlashMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraFlashMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraFlashMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraFlashMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraFlashMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraFlashMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraFlashMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraFlashMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraFlashMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraFlashMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraFlashMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraFlashMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraFlashMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraFlashMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraFlashMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::read(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::read(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::read(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::read(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::read(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::read(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  mvIMPACT::acquire::TCameraFlashMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraFlashMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraFlashMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  mvIMPACT::acquire::TCameraFlashMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraFlashMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraFlashMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraFlashMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashMode >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraFlashMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraFlashMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraFlashMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraFlashMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraFlashMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraFlashMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::write(mvIMPACT::acquire::TCameraFlashMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::write(mvIMPACT::acquire::TCameraFlashMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::write(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::write(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::write(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >::write(std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraFlashMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraFlashMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraFlashMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraFlashMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraFlashMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraFlashMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraFlashMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraFlashMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraFlashMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraFlashMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraFlashMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraFlashMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraFlashMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraFlashMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode >((std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraFlashMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraFlashMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTCameraFlashMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraFlashMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraFlashMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraFlashMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode >::pair(std::string,mvIMPACT::acquire::TCameraFlashMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraFlashMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraFlashMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraFlashMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraFlashMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraFlashMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraFlashMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraFlashMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraFlashMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  mvIMPACT::acquire::TCameraFlashMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraFlashMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraFlashMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraFlashMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraFlashMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraFlashMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraFlashMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraFlashMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraFlashMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraFlashMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraFlashMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraFlashMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraFlashMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraFlashMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraFlashType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraFlashType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraFlashType" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraFlashType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraFlashType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraFlashType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraFlashType(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraFlashType", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraFlashType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraFlashType__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraFlashType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraFlashType'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraFlashType_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraFlashType> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraFlashType> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraFlashType> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraFlashType>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraFlashType>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashType_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraFlashType_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraFlashType_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraFlashType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraFlashType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashType_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraFlashType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraFlashType_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraFlashType_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraFlashType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraFlashType_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraFlashType_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraFlashType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashType_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraFlashType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraFlashType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraFlashType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraFlashType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraFlashType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraFlashType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraFlashType_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraFlashType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraFlashType_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraFlashType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraFlashType_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraFlashType_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraFlashType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::read(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::read(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::read(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::read(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::read(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::read(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  mvIMPACT::acquire::TCameraFlashType arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraFlashType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraFlashType >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  mvIMPACT::acquire::TCameraFlashType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraFlashType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraFlashType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraFlashType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraFlashType_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraFlashType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraFlashType >* pV = new std::vector<mvIMPACT::acquire::TCameraFlashType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraFlashType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraFlashType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraFlashType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraFlashType_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraFlashType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraFlashType_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraFlashType_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraFlashType_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraFlashType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::write(mvIMPACT::acquire::TCameraFlashType,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::write(mvIMPACT::acquire::TCameraFlashType) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::write(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::write(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::write(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >::write(std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraFlashType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraFlashType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraFlashType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraFlashType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraFlashType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *)new std::pair< std::string,mvIMPACT::acquire::TCameraFlashType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraFlashType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraFlashType arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraFlashType" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraFlashType" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraFlashType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraFlashType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *)new std::pair< std::string,mvIMPACT::acquire::TCameraFlashType >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraFlashType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraFlashType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraFlashType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *)new std::pair< std::string,mvIMPACT::acquire::TCameraFlashType >((std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraFlashType(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraFlashType", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTCameraFlashType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraFlashType__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraFlashType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraFlashType'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraFlashType >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraFlashType >::pair(std::string,mvIMPACT::acquire::TCameraFlashType)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraFlashType >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraFlashType_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraFlashType_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraFlashType_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraFlashType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraFlashType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraFlashType_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraFlashType_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraFlashType_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  mvIMPACT::acquire::TCameraFlashType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraFlashType_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraFlashType_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraFlashType_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraFlashType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraFlashType >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraFlashType_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraFlashType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraFlashType_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraFlashType) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraFlashType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraFlashType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraFlashType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraFlashType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraHDRMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraHDRMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraHDRMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraHDRMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraHDRMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraHDRMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraHDRMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraHDRMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyICameraHDRMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraHDRMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraHDRMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraHDRMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraHDRMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraHDRMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraHDRMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraHDRMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraHDRMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraHDRMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraHDRMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraHDRMode_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraHDRMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraHDRMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraHDRMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraHDRMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraHDRMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraHDRMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraHDRMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraHDRMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraHDRMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraHDRMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraHDRMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraHDRMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraHDRMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraHDRMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraHDRMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraHDRMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraHDRMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraHDRMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraHDRMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraHDRMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraHDRMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraHDRMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraHDRMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraHDRMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraHDRMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraHDRMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraHDRMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraHDRMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraHDRMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraHDRMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraHDRMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraHDRMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraHDRMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraHDRMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraHDRMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraHDRMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraHDRMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::read(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::read(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::read(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::read(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::read(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::read(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  mvIMPACT::acquire::TCameraHDRMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraHDRMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraHDRMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraHDRMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraHDRMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  mvIMPACT::acquire::TCameraHDRMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraHDRMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraHDRMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraHDRMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraHDRMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraHDRMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraHDRMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraHDRMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraHDRMode >* pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraHDRMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraHDRMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraHDRMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraHDRMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraHDRMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraHDRMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraHDRMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraHDRMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraHDRMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraHDRMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraHDRMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::write(mvIMPACT::acquire::TCameraHDRMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::write(mvIMPACT::acquire::TCameraHDRMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::write(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::write(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::write(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >::write(std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraHDRMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraHDRMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraHDRMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraHDRMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraHDRMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraHDRMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraHDRMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraHDRMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraHDRMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraHDRMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraHDRMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraHDRMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraHDRMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraHDRMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode >((std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraHDRMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraHDRMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraHDRMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraHDRMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraHDRMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraHDRMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode >::pair(std::string,mvIMPACT::acquire::TCameraHDRMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraHDRMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraHDRMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraHDRMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraHDRMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraHDRMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraHDRMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraHDRMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraHDRMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  mvIMPACT::acquire::TCameraHDRMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraHDRMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraHDRMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraHDRMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraHDRMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraHDRMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraHDRMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraHDRMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraHDRMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraHDRMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraHDRMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraHDRMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraHDRMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraHDRMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraInterlacedType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraInterlacedType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraInterlacedType" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraInterlacedType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraInterlacedType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraInterlacedType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraInterlacedType(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraInterlacedType", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraInterlacedType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyICameraInterlacedType__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyICameraInterlacedType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraInterlacedType'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraInterlacedType_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraInterlacedType> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraInterlacedType> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraInterlacedType> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraInterlacedType>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraInterlacedType>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraInterlacedType_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraInterlacedType_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraInterlacedType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraInterlacedType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraInterlacedType_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraInterlacedType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraInterlacedType_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraInterlacedType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraInterlacedType_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraInterlacedType_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraInterlacedType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraInterlacedType_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraInterlacedType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraInterlacedType result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraInterlacedType result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraInterlacedType result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraInterlacedType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraInterlacedType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraInterlacedType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraInterlacedType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraInterlacedType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraInterlacedType_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraInterlacedType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraInterlacedType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraInterlacedType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraInterlacedType_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraInterlacedType_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraInterlacedType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraInterlacedType_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraInterlacedType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::read(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::read(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::read(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::read(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::read(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::read(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  mvIMPACT::acquire::TCameraInterlacedType arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraInterlacedType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraInterlacedType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraInterlacedType >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraInterlacedType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  mvIMPACT::acquire::TCameraInterlacedType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraInterlacedType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraInterlacedType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraInterlacedType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraInterlacedType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraInterlacedType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraInterlacedType_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraInterlacedType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraInterlacedType >* pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraInterlacedType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraInterlacedType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraInterlacedType>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraInterlacedType_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraInterlacedType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraInterlacedType_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraInterlacedType_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraInterlacedType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::write(mvIMPACT::acquire::TCameraInterlacedType,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::write(mvIMPACT::acquire::TCameraInterlacedType) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::write(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::write(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::write(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >::write(std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraInterlacedType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraInterlacedType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraInterlacedType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraInterlacedType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraInterlacedType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *)new std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraInterlacedType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraInterlacedType arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraInterlacedType" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraInterlacedType" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraInterlacedType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraInterlacedType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *)new std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraInterlacedType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraInterlacedType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraInterlacedType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *)new std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType >((std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraInterlacedType(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraInterlacedType", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraInterlacedType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraInterlacedType__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraInterlacedType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraInterlacedType'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType >::pair(std::string,mvIMPACT::acquire::TCameraInterlacedType)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraInterlacedType_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraInterlacedType_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraInterlacedType_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraInterlacedType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraInterlacedType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraInterlacedType_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraInterlacedType_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraInterlacedType_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  mvIMPACT::acquire::TCameraInterlacedType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraInterlacedType_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraInterlacedType_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraInterlacedType_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraInterlacedType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraInterlacedType >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraInterlacedType_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraInterlacedType result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraInterlacedType_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraInterlacedType) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraInterlacedType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraInterlacedType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraInterlacedType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraInterlacedType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraLinkDataValidMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraLinkDataValidMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraLinkDataValidMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraLinkDataValidMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraLinkDataValidMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraLinkDataValidMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraLinkDataValidMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraLinkDataValidMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraLinkDataValidMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyICameraLinkDataValidMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyICameraLinkDataValidMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraLinkDataValidMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraLinkDataValidMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraLinkDataValidMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraLinkDataValidMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraLinkDataValidMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraLinkDataValidMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraLinkDataValidMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraLinkDataValidMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraLinkDataValidMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraLinkDataValidMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraLinkDataValidMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraLinkDataValidMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraLinkDataValidMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraLinkDataValidMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraLinkDataValidMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraLinkDataValidMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraLinkDataValidMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraLinkDataValidMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraLinkDataValidMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraLinkDataValidMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraLinkDataValidMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraLinkDataValidMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraLinkDataValidMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::read(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::read(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::read(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::read(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::read(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::read(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  mvIMPACT::acquire::TCameraLinkDataValidMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraLinkDataValidMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraLinkDataValidMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  mvIMPACT::acquire::TCameraLinkDataValidMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraLinkDataValidMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraLinkDataValidMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >* pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraLinkDataValidMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraLinkDataValidMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraLinkDataValidMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraLinkDataValidMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraLinkDataValidMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraLinkDataValidMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraLinkDataValidMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::write(mvIMPACT::acquire::TCameraLinkDataValidMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::write(mvIMPACT::acquire::TCameraLinkDataValidMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::write(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::write(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::write(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >::write(std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraLinkDataValidMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraLinkDataValidMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraLinkDataValidMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraLinkDataValidMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraLinkDataValidMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraLinkDataValidMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraLinkDataValidMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  { std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraLinkDataValidMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraLinkDataValidMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraLinkDataValidMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraLinkDataValidMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraLinkDataValidMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraLinkDataValidMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraLinkDataValidMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode >((std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraLinkDataValidMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraLinkDataValidMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraLinkDataValidMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraLinkDataValidMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraLinkDataValidMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraLinkDataValidMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode >::pair(std::string,mvIMPACT::acquire::TCameraLinkDataValidMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraLinkDataValidMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraLinkDataValidMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraLinkDataValidMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraLinkDataValidMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraLinkDataValidMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraLinkDataValidMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraLinkDataValidMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraLinkDataValidMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  mvIMPACT::acquire::TCameraLinkDataValidMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraLinkDataValidMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraLinkDataValidMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraLinkDataValidMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraLinkDataValidMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraLinkDataValidMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraLinkDataValidMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraLinkDataValidMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraLinkDataValidMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraLinkDataValidMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraLinkDataValidMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraLinkDataValidMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraLinkDataValidMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraLinkDataValidMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraOutput__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraOutput(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraOutput", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyICameraOutput__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraOutput__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraOutput__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraOutput'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraOutput >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraOutput_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraOutput> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraOutput> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraOutput> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraOutput>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraOutput>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraOutput_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraOutput_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraOutput_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraOutput_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraOutput_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraOutput result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraOutput_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraOutput result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraOutput_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraOutput_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraOutput_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraOutput_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraOutput_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraOutput_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraOutput result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraOutput_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraOutput result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraOutput result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraOutput result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraOutput result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraOutput_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraOutput_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraOutput_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraOutput_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraOutput_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraOutput_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraOutput_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraOutput_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraOutput_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraOutput_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraOutput_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraOutput_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraOutput_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraOutput_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraOutput_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraOutput_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraOutput_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraOutput_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraOutput_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::read(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::read(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::read(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::read(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::read(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::read(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  mvIMPACT::acquire::TCameraOutput arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraOutput_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraOutput""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraOutput >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraOutput_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  mvIMPACT::acquire::TCameraOutput arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraOutput_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraOutput""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraOutput >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraOutput_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraOutput_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraOutput_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraOutput_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraOutput >* pV = new std::vector<mvIMPACT::acquire::TCameraOutput > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraOutput_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraOutput >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraOutput>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraOutput_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraOutput_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraOutput_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraOutput_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraOutput_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraOutput_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraOutput_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraOutput_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::write(mvIMPACT::acquire::TCameraOutput,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::write(mvIMPACT::acquire::TCameraOutput) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::write(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::write(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::write(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >::write(std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraOutput_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *)new std::pair< std::string,mvIMPACT::acquire::TCameraOutput >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraOutput arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraOutput" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraOutput" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraOutput""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraOutput >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *)new std::pair< std::string,mvIMPACT::acquire::TCameraOutput >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraOutput__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraOutput" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraOutput > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraOutput" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraOutput > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *)new std::pair< std::string,mvIMPACT::acquire::TCameraOutput >((std::pair< std::string,mvIMPACT::acquire::TCameraOutput > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraOutput(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraOutput", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraOutput__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraOutput__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraOutput__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraOutput'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraOutput >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraOutput >::pair(std::string,mvIMPACT::acquire::TCameraOutput)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraOutput >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraOutput > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraOutput_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraOutput_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraOutput_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraOutput_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraOutput_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraOutput_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraOutput_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraOutput_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *) 0 ;
  mvIMPACT::acquire::TCameraOutput arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraOutput_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraOutput_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraOutput_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraOutput""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraOutput >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraOutput_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraOutput result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraOutput_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraOutput) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraOutput" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraOutput_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraPixelClock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraPixelClock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraPixelClock" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraPixelClock__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraPixelClock" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraPixelClock" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraPixelClock(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraPixelClock", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyICameraPixelClock__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraPixelClock__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraPixelClock__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraPixelClock'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraPixelClock_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraPixelClock> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraPixelClock> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraPixelClock> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraPixelClock>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraPixelClock>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraPixelClock_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraPixelClock_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraPixelClock_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraPixelClock result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraPixelClock_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraPixelClock result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraPixelClock_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraPixelClock_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraPixelClock_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraPixelClock_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraPixelClock_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraPixelClock result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraPixelClock_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraPixelClock result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraPixelClock result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraPixelClock result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraPixelClock result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraPixelClock_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraPixelClock_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraPixelClock_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraPixelClock_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraPixelClock_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraPixelClock_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraPixelClock_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraPixelClock_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraPixelClock_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraPixelClock_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraPixelClock_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraPixelClock_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraPixelClock_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraPixelClock_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::read(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::read(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::read(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::read(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::read(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::read(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  mvIMPACT::acquire::TCameraPixelClock arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraPixelClock_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraPixelClock""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraPixelClock >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraPixelClock_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  mvIMPACT::acquire::TCameraPixelClock arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraPixelClock_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraPixelClock""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraPixelClock >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraPixelClock_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraPixelClock_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraPixelClock_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraPixelClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraPixelClock >* pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraPixelClock_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraPixelClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraPixelClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraPixelClock_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraPixelClock_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraPixelClock_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraPixelClock_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraPixelClock_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraPixelClock_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::write(mvIMPACT::acquire::TCameraPixelClock,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::write(mvIMPACT::acquire::TCameraPixelClock) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::write(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::write(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::write(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >::write(std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraPixelClock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraPixelClock" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraPixelClock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraPixelClock_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraPixelClock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *)new std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraPixelClock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraPixelClock arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraPixelClock" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraPixelClock" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraPixelClock""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraPixelClock >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *)new std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraPixelClock__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraPixelClock" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraPixelClock" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *)new std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock >((std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraPixelClock(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraPixelClock", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraPixelClock__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraPixelClock__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraPixelClock__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraPixelClock'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock >::pair(std::string,mvIMPACT::acquire::TCameraPixelClock)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraPixelClock_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraPixelClock_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraPixelClock_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraPixelClock_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraPixelClock_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraPixelClock_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraPixelClock_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraPixelClock_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  mvIMPACT::acquire::TCameraPixelClock arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraPixelClock_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraPixelClock_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraPixelClock_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraPixelClock""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraPixelClock >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraPixelClock_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraPixelClock result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraPixelClock_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraPixelClock) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraPixelClock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraPixelClock" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraPixelClock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraPixelClock_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraScanMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraScanMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraScanMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraScanMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraScanMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraScanMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraScanMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraScanMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraScanMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraScanMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraScanMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraScanMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraScanMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraScanMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraScanMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraScanMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraScanMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraScanMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraScanMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraScanMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraScanMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraScanMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraScanMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraScanMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraScanMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraScanMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraScanMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraScanMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraScanMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraScanMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraScanMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraScanMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraScanMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraScanMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraScanMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraScanMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraScanMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraScanMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraScanMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraScanMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraScanMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraScanMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraScanMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraScanMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraScanMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraScanMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraScanMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraScanMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraScanMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraScanMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraScanMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraScanMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraScanMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraScanMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraScanMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraScanMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraScanMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::read(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::read(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::read(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::read(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::read(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::read(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  mvIMPACT::acquire::TCameraScanMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraScanMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraScanMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraScanMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraScanMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  mvIMPACT::acquire::TCameraScanMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraScanMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraScanMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraScanMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraScanMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraScanMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraScanMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraScanMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraScanMode >* pV = new std::vector<mvIMPACT::acquire::TCameraScanMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraScanMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraScanMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraScanMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraScanMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraScanMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraScanMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraScanMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraScanMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraScanMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraScanMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraScanMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::write(mvIMPACT::acquire::TCameraScanMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::write(mvIMPACT::acquire::TCameraScanMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::write(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::write(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::write(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >::write(std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraScanMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraScanMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraScanMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraScanMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraScanMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraScanMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraScanMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraScanMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraScanMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraScanMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraScanMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraScanMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraScanMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraScanMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraScanMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraScanMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraScanMode >((std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraScanMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraScanMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTCameraScanMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraScanMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraScanMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraScanMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraScanMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraScanMode >::pair(std::string,mvIMPACT::acquire::TCameraScanMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraScanMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraScanMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraScanMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraScanMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraScanMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraScanMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraScanMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraScanMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraScanMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  mvIMPACT::acquire::TCameraScanMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraScanMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraScanMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraScanMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraScanMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraScanMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraScanMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraScanMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraScanMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraScanMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraScanMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraScanMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraScanMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraScanMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraSerialPortBaudRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraSerialPortBaudRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraSerialPortBaudRate" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraSerialPortBaudRate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraSerialPortBaudRate" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraSerialPortBaudRate" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraSerialPortBaudRate(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraSerialPortBaudRate", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraSerialPortBaudRate__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyICameraSerialPortBaudRate__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyICameraSerialPortBaudRate__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraSerialPortBaudRate'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraSerialPortBaudRate_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraSerialPortBaudRate> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraSerialPortBaudRate> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraSerialPortBaudRate> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraSerialPortBaudRate>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraSerialPortBaudRate>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraSerialPortBaudRate_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraSerialPortBaudRate_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraSerialPortBaudRate result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraSerialPortBaudRate result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraSerialPortBaudRate_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraSerialPortBaudRate_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraSerialPortBaudRate_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraSerialPortBaudRate_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraSerialPortBaudRate result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraSerialPortBaudRate result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraSerialPortBaudRate result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraSerialPortBaudRate result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraSerialPortBaudRate result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraSerialPortBaudRate_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraSerialPortBaudRate_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraSerialPortBaudRate_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::read(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::read(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::read(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::read(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::read(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::read(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  mvIMPACT::acquire::TCameraSerialPortBaudRate arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraSerialPortBaudRate""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraSerialPortBaudRate >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  mvIMPACT::acquire::TCameraSerialPortBaudRate arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraSerialPortBaudRate""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraSerialPortBaudRate >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >* pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraSerialPortBaudRate_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraSerialPortBaudRate>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraSerialPortBaudRate_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraSerialPortBaudRate_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::write(mvIMPACT::acquire::TCameraSerialPortBaudRate,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::write(mvIMPACT::acquire::TCameraSerialPortBaudRate) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::write(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::write(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::write(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >::write(std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraSerialPortBaudRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraSerialPortBaudRate" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraSerialPortBaudRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraSerialPortBaudRate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraSerialPortBaudRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *)new std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraSerialPortBaudRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraSerialPortBaudRate arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  { std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraSerialPortBaudRate" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraSerialPortBaudRate" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraSerialPortBaudRate""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraSerialPortBaudRate >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *)new std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraSerialPortBaudRate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraSerialPortBaudRate" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraSerialPortBaudRate" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *)new std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate >((std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraSerialPortBaudRate(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraSerialPortBaudRate", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraSerialPortBaudRate__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraSerialPortBaudRate__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraSerialPortBaudRate__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraSerialPortBaudRate'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate >::pair(std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraSerialPortBaudRate_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraSerialPortBaudRate_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraSerialPortBaudRate_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraSerialPortBaudRate_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraSerialPortBaudRate_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraSerialPortBaudRate_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraSerialPortBaudRate_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraSerialPortBaudRate_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  mvIMPACT::acquire::TCameraSerialPortBaudRate arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraSerialPortBaudRate_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraSerialPortBaudRate_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraSerialPortBaudRate_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraSerialPortBaudRate""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraSerialPortBaudRate >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraSerialPortBaudRate_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraSerialPortBaudRate result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraSerialPortBaudRate_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraSerialPortBaudRate) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraSerialPortBaudRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraSerialPortBaudRate" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraSerialPortBaudRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraSerialPortBaudRate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraShutterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraShutterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraShutterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraShutterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraShutterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraShutterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraShutterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraShutterMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyICameraShutterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraShutterMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraShutterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraShutterMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraShutterMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraShutterMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraShutterMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraShutterMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraShutterMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraShutterMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraShutterMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraShutterMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraShutterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraShutterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraShutterMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraShutterMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraShutterMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraShutterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraShutterMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraShutterMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraShutterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraShutterMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraShutterMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraShutterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraShutterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraShutterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraShutterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraShutterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraShutterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraShutterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraShutterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraShutterMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraShutterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraShutterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraShutterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraShutterMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraShutterMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraShutterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraShutterMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraShutterMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraShutterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::read(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::read(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::read(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::read(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::read(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::read(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  mvIMPACT::acquire::TCameraShutterMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraShutterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraShutterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraShutterMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraShutterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  mvIMPACT::acquire::TCameraShutterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraShutterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraShutterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraShutterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraShutterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraShutterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraShutterMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraShutterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraShutterMode >* pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraShutterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraShutterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraShutterMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraShutterMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraShutterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraShutterMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraShutterMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraShutterMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraShutterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::write(mvIMPACT::acquire::TCameraShutterMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::write(mvIMPACT::acquire::TCameraShutterMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::write(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::write(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::write(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >::write(std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraShutterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraShutterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraShutterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraShutterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraShutterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraShutterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraShutterMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraShutterMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraShutterMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraShutterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraShutterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraShutterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraShutterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraShutterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode >((std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraShutterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraShutterMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraShutterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraShutterMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraShutterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraShutterMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode >::pair(std::string,mvIMPACT::acquire::TCameraShutterMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraShutterMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraShutterMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraShutterMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraShutterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraShutterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraShutterMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraShutterMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraShutterMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  mvIMPACT::acquire::TCameraShutterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraShutterMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraShutterMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraShutterMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraShutterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraShutterMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraShutterMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraShutterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraShutterMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraShutterMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraShutterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraShutterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraShutterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraShutterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraTapsXGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTapsXGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraTapsXGeometry" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTapsXGeometry__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraTapsXGeometry" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraTapsXGeometry" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTapsXGeometry(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraTapsXGeometry", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraTapsXGeometry__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyICameraTapsXGeometry__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyICameraTapsXGeometry__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraTapsXGeometry'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTapsXGeometry_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraTapsXGeometry> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTapsXGeometry> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTapsXGeometry> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraTapsXGeometry>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraTapsXGeometry>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsXGeometry_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTapsXGeometry_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTapsXGeometry_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTapsXGeometry result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsXGeometry_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTapsXGeometry result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTapsXGeometry_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTapsXGeometry_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTapsXGeometry_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTapsXGeometry_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTapsXGeometry result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTapsXGeometry result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTapsXGeometry result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTapsXGeometry result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTapsXGeometry result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsXGeometry_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTapsXGeometry_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTapsXGeometry_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  mvIMPACT::acquire::TCameraTapsXGeometry arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTapsXGeometry""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTapsXGeometry >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  mvIMPACT::acquire::TCameraTapsXGeometry arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTapsXGeometry""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTapsXGeometry >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsXGeometry_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsXGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsXGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTapsXGeometry_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTapsXGeometry_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTapsXGeometry_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTapsXGeometry_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTapsXGeometry_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::write(mvIMPACT::acquire::TCameraTapsXGeometry,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::write(mvIMPACT::acquire::TCameraTapsXGeometry) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::write(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::write(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::write(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >::write(std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraTapsXGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraTapsXGeometry" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraTapsXGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraTapsXGeometry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraTapsXGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTapsXGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraTapsXGeometry arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraTapsXGeometry" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraTapsXGeometry" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTapsXGeometry""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTapsXGeometry >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTapsXGeometry__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraTapsXGeometry" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraTapsXGeometry" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry >((std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTapsXGeometry(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraTapsXGeometry", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraTapsXGeometry__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraTapsXGeometry__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraTapsXGeometry__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraTapsXGeometry'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry >::pair(std::string,mvIMPACT::acquire::TCameraTapsXGeometry)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTapsXGeometry_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTapsXGeometry_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTapsXGeometry_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraTapsXGeometry_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraTapsXGeometry_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTapsXGeometry_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTapsXGeometry_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTapsXGeometry_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  mvIMPACT::acquire::TCameraTapsXGeometry arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTapsXGeometry_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTapsXGeometry_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraTapsXGeometry_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTapsXGeometry""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTapsXGeometry >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTapsXGeometry_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTapsXGeometry result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTapsXGeometry_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraTapsXGeometry) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraTapsXGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraTapsXGeometry" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraTapsXGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraTapsXGeometry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraTapsYGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTapsYGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraTapsYGeometry" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTapsYGeometry__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraTapsYGeometry" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraTapsYGeometry" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTapsYGeometry(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraTapsYGeometry", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraTapsYGeometry__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyICameraTapsYGeometry__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyICameraTapsYGeometry__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraTapsYGeometry'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTapsYGeometry_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraTapsYGeometry> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTapsYGeometry> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTapsYGeometry> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraTapsYGeometry>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraTapsYGeometry>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsYGeometry_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTapsYGeometry_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTapsYGeometry_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTapsYGeometry result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsYGeometry_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTapsYGeometry result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTapsYGeometry_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTapsYGeometry_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTapsYGeometry_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTapsYGeometry_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTapsYGeometry result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTapsYGeometry result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTapsYGeometry result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTapsYGeometry result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTapsYGeometry result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsYGeometry_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTapsYGeometry_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTapsYGeometry_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::read(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  mvIMPACT::acquire::TCameraTapsYGeometry arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTapsYGeometry""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTapsYGeometry >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  mvIMPACT::acquire::TCameraTapsYGeometry arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTapsYGeometry""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTapsYGeometry >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >* pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTapsYGeometry_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTapsYGeometry >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTapsYGeometry>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTapsYGeometry_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTapsYGeometry_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTapsYGeometry_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTapsYGeometry_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTapsYGeometry_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::write(mvIMPACT::acquire::TCameraTapsYGeometry,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::write(mvIMPACT::acquire::TCameraTapsYGeometry) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::write(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::write(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::write(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >::write(std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraTapsYGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraTapsYGeometry" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraTapsYGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraTapsYGeometry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraTapsYGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTapsYGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraTapsYGeometry arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraTapsYGeometry" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraTapsYGeometry" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTapsYGeometry""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTapsYGeometry >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTapsYGeometry__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraTapsYGeometry" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraTapsYGeometry" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry >((std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTapsYGeometry(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraTapsYGeometry", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraTapsYGeometry__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraTapsYGeometry__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraTapsYGeometry__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraTapsYGeometry'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry >::pair(std::string,mvIMPACT::acquire::TCameraTapsYGeometry)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTapsYGeometry_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTapsYGeometry_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTapsYGeometry_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraTapsYGeometry_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraTapsYGeometry_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTapsYGeometry_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTapsYGeometry_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTapsYGeometry_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  mvIMPACT::acquire::TCameraTapsYGeometry arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTapsYGeometry_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTapsYGeometry_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraTapsYGeometry_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTapsYGeometry""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTapsYGeometry >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTapsYGeometry_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTapsYGeometry result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTapsYGeometry_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraTapsYGeometry) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraTapsYGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraTapsYGeometry" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraTapsYGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraTapsYGeometry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraTestMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTestMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraTestMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTestMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraTestMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraTestMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTestMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraTestMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraTestMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraTestMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraTestMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraTestMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTestMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraTestMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTestMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTestMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraTestMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraTestMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTestMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTestMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraTestMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTestMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTestMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTestMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTestMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTestMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTestMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraTestMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTestMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTestMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTestMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTestMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTestMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTestMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTestMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTestMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTestMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTestMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTestMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTestMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTestMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTestMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTestMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraTestMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTestMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTestMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTestMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTestMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraTestMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTestMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTestMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTestMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTestMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraTestMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTestMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraTestMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTestMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::read(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::read(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::read(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::read(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::read(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::read(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  mvIMPACT::acquire::TCameraTestMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTestMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTestMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTestMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTestMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  mvIMPACT::acquire::TCameraTestMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTestMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTestMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTestMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTestMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTestMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTestMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTestMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTestMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTestMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTestMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTestMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTestMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTestMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTestMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraTestMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTestMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTestMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTestMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::write(mvIMPACT::acquire::TCameraTestMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::write(mvIMPACT::acquire::TCameraTestMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::write(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::write(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::write(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >::write(std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraTestMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraTestMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraTestMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraTestMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraTestMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTestMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTestMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraTestMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraTestMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraTestMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTestMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTestMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTestMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTestMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraTestMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraTestMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTestMode >((std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTestMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraTestMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTCameraTestMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraTestMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraTestMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraTestMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraTestMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTestMode >::pair(std::string,mvIMPACT::acquire::TCameraTestMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTestMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTestMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTestMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTestMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraTestMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraTestMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTestMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTestMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTestMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  mvIMPACT::acquire::TCameraTestMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTestMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTestMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraTestMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTestMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTestMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTestMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTestMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTestMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraTestMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraTestMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraTestMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraTestMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraTestMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraTriggerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTriggerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraTriggerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTriggerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraTriggerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraTriggerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTriggerMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraTriggerMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyICameraTriggerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyICameraTriggerMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyICameraTriggerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraTriggerMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraTriggerMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTriggerMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTriggerMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraTriggerMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraTriggerMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTriggerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTriggerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTriggerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTriggerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTriggerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTriggerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTriggerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTriggerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTriggerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTriggerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTriggerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraTriggerMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTriggerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraTriggerMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTriggerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTriggerMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTriggerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::read(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::read(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::read(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::read(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::read(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::read(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  mvIMPACT::acquire::TCameraTriggerMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTriggerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTriggerMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  mvIMPACT::acquire::TCameraTriggerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTriggerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTriggerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTriggerMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTriggerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTriggerMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTriggerMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTriggerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::write(mvIMPACT::acquire::TCameraTriggerMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::write(mvIMPACT::acquire::TCameraTriggerMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::write(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::write(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::write(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >::write(std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraTriggerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraTriggerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraTriggerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraTriggerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraTriggerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTriggerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraTriggerMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraTriggerMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraTriggerMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTriggerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTriggerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTriggerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraTriggerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraTriggerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode >((std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTriggerMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraTriggerMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraTriggerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraTriggerMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraTriggerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraTriggerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode >::pair(std::string,mvIMPACT::acquire::TCameraTriggerMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTriggerMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTriggerMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTriggerMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraTriggerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraTriggerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTriggerMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTriggerMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTriggerMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  mvIMPACT::acquire::TCameraTriggerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTriggerMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTriggerMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraTriggerMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTriggerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTriggerMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTriggerMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTriggerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTriggerMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraTriggerMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraTriggerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraTriggerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraTriggerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraTriggerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyICameraTriggerSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTriggerSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyICameraTriggerSource" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTriggerSource__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyICameraTriggerSource" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyICameraTriggerSource" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyICameraTriggerSource(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyICameraTriggerSource", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyICameraTriggerSource__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyICameraTriggerSource__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyICameraTriggerSource__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyICameraTriggerSource'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerSource_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TCameraTriggerSource> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTriggerSource> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TCameraTriggerSource> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TCameraTriggerSource>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TCameraTriggerSource>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerSource_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerSource_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTriggerSource_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTriggerSource result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerSource_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTriggerSource result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerSource_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTriggerSource_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerSource_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerSource_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TCameraTriggerSource result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerSource_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TCameraTriggerSource result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTriggerSource result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTriggerSource result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTriggerSource result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerSource_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTriggerSource_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerSource_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerSource_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTriggerSource_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyICameraTriggerSource_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerSource_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTriggerSource_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerSource_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerSource_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyICameraTriggerSource_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTriggerSource_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTriggerSource_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTriggerSource_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::read(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::read(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::read(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::read(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::read(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::read(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  mvIMPACT::acquire::TCameraTriggerSource arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerSource_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTriggerSource""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTriggerSource >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerSource_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  mvIMPACT::acquire::TCameraTriggerSource arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyICameraTriggerSource_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTriggerSource""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTriggerSource >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerSource_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerSource_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyICameraTriggerSource_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyICameraTriggerSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TCameraTriggerSource >* pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyICameraTriggerSource_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TCameraTriggerSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TCameraTriggerSource>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyICameraTriggerSource_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTriggerSource_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTriggerSource_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyICameraTriggerSource_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyICameraTriggerSource_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::write(mvIMPACT::acquire::TCameraTriggerSource,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::write(mvIMPACT::acquire::TCameraTriggerSource) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::write(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::write(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::write(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >::write(std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyICameraTriggerSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyICameraTriggerSource" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyICameraTriggerSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyICameraTriggerSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTCameraTriggerSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTriggerSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TCameraTriggerSource arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTCameraTriggerSource" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTCameraTriggerSource" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTriggerSource""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTriggerSource >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTriggerSource__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *ptr = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTCameraTriggerSource" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTCameraTriggerSource" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *)new std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource >((std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTCameraTriggerSource(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTCameraTriggerSource", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTCameraTriggerSource__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTCameraTriggerSource__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTCameraTriggerSource__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTCameraTriggerSource'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource >::pair(std::string,mvIMPACT::acquire::TCameraTriggerSource)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource >::pair(std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTriggerSource_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTriggerSource_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTriggerSource_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTCameraTriggerSource_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTCameraTriggerSource_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTriggerSource_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTriggerSource_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTriggerSource_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  mvIMPACT::acquire::TCameraTriggerSource arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTCameraTriggerSource_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTriggerSource_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTCameraTriggerSource_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TCameraTriggerSource""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TCameraTriggerSource >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTCameraTriggerSource_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TCameraTriggerSource result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTCameraTriggerSource_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TCameraTriggerSource) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTCameraTriggerSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTCameraTriggerSource" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTCameraTriggerSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTCameraTriggerSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIChannelSplitMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIChannelSplitMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIChannelSplitMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIChannelSplitMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIChannelSplitMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIChannelSplitMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIChannelSplitMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIChannelSplitMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIChannelSplitMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIChannelSplitMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIChannelSplitMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIChannelSplitMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIChannelSplitMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TChannelSplitMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TChannelSplitMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TChannelSplitMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TChannelSplitMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TChannelSplitMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIChannelSplitMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIChannelSplitMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIChannelSplitMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TChannelSplitMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIChannelSplitMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TChannelSplitMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIChannelSplitMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIChannelSplitMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIChannelSplitMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIChannelSplitMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIChannelSplitMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TChannelSplitMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIChannelSplitMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TChannelSplitMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TChannelSplitMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TChannelSplitMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TChannelSplitMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIChannelSplitMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIChannelSplitMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIChannelSplitMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIChannelSplitMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIChannelSplitMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIChannelSplitMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIChannelSplitMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIChannelSplitMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIChannelSplitMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIChannelSplitMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIChannelSplitMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIChannelSplitMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIChannelSplitMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::read(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::read(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::read(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::read(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::read(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::read(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  mvIMPACT::acquire::TChannelSplitMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIChannelSplitMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TChannelSplitMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TChannelSplitMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIChannelSplitMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  mvIMPACT::acquire::TChannelSplitMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIChannelSplitMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TChannelSplitMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TChannelSplitMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIChannelSplitMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIChannelSplitMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIChannelSplitMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIChannelSplitMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TChannelSplitMode >* pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIChannelSplitMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TChannelSplitMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TChannelSplitMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIChannelSplitMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIChannelSplitMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIChannelSplitMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIChannelSplitMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIChannelSplitMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::write(mvIMPACT::acquire::TChannelSplitMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::write(mvIMPACT::acquire::TChannelSplitMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::write(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::write(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::write(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >::write(std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIChannelSplitMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIChannelSplitMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIChannelSplitMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIChannelSplitMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTChannelSplitMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *)new std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTChannelSplitMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TChannelSplitMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTChannelSplitMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTChannelSplitMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TChannelSplitMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TChannelSplitMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *)new std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTChannelSplitMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTChannelSplitMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTChannelSplitMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *)new std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode >((std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTChannelSplitMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTChannelSplitMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTChannelSplitMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTChannelSplitMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTChannelSplitMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTChannelSplitMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode >::pair(std::string,mvIMPACT::acquire::TChannelSplitMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode >::pair(std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTChannelSplitMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTChannelSplitMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTChannelSplitMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTChannelSplitMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTChannelSplitMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTChannelSplitMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTChannelSplitMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTChannelSplitMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  mvIMPACT::acquire::TChannelSplitMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTChannelSplitMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTChannelSplitMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTChannelSplitMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TChannelSplitMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TChannelSplitMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTChannelSplitMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TChannelSplitMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTChannelSplitMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TChannelSplitMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTChannelSplitMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTChannelSplitMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTChannelSplitMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTChannelSplitMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIClampMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIClampMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIClampMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIClampMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIClampMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIClampMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIClampMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIClampMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIClampMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIClampMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIClampMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIClampMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TClampMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TClampMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIClampMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TClampMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TClampMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TClampMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TClampMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TClampMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIClampMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIClampMode_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIClampMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIClampMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIClampMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TClampMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIClampMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TClampMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIClampMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIClampMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIClampMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIClampMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIClampMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIClampMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; }  { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TClampMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIClampMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TClampMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TClampMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TClampMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TClampMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; int arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIClampMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIClampMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIClampMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; }  { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIClampMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIClampMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIClampMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIClampMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIClampMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIClampMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIClampMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIClampMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIClampMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIClampMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIClampMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIClampMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIClampMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIClampMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIClampMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIClampMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::read(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::read(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::read(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::read(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::read(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::read(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  mvIMPACT::acquire::TClampMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIClampMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TClampMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TClampMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIClampMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  mvIMPACT::acquire::TClampMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIClampMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TClampMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TClampMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIClampMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; }  { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIClampMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIClampMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIClampMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TClampMode >* pV = new std::vector<mvIMPACT::acquire::TClampMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIClampMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TClampMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TClampMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIClampMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIClampMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIClampMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIClampMode_write__SWIG_5(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIClampMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIClampMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIClampMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIClampMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::write(mvIMPACT::acquire::TClampMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::write(mvIMPACT::acquire::TClampMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::write(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::write(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::write(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >::write(std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIClampMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIClampMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIClampMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIClampMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTClampMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TClampMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TClampMode > *)new std::pair< std::string,mvIMPACT::acquire::TClampMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTClampMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TClampMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TClampMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTClampMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTClampMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TClampMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TClampMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TClampMode > *)new std::pair< std::string,mvIMPACT::acquire::TClampMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTClampMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TClampMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TClampMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TClampMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TClampMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTClampMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TClampMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTClampMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TClampMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TClampMode > *)new std::pair< std::string,mvIMPACT::acquire::TClampMode >((std::pair< std::string,mvIMPACT::acquire::TClampMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTClampMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTClampMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTClampMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTClampMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTClampMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTClampMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TClampMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TClampMode >::pair(std::string,mvIMPACT::acquire::TClampMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TClampMode >::pair(std::pair< std::string,mvIMPACT::acquire::TClampMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTClampMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TClampMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TClampMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTClampMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTClampMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TClampMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TClampMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTClampMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTClampMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTClampMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TClampMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTClampMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TClampMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TClampMode > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTClampMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TClampMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TClampMode > *) 0 ;
  mvIMPACT::acquire::TClampMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTClampMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTClampMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TClampMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TClampMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTClampMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TClampMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TClampMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTClampMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TClampMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TClampMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTClampMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TClampMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TClampMode > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::TClampMode) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTClampMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TClampMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TClampMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTClampMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TClampMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TClampMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTClampMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTClampMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIColorTwistInputCorrectionMatrixMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIColorTwistInputCorrectionMatrixMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIColorTwistInputCorrectionMatrixMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIColorTwistInputCorrectionMatrixMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIColorTwistInputCorrectionMatrixMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIColorTwistInputCorrectionMatrixMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &""'"); }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIColorTwistInputCorrectionMatrixMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIColorTwistInputCorrectionMatrixMode", 0, 1, argv))) SWIG_fail;
  --argc; if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIColorTwistInputCorrectionMatrixMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIColorTwistInputCorrectionMatrixMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIColorTwistInputCorrectionMatrixMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIColorTwistInputCorrectionMatrixMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorTwistInputCorrectionMatrixMode_read", 0, 5, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorTwistInputCorrectionMatrixMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >(val2); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorTwistInputCorrectionMatrixMode_write", 0, 4, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorTwistInputCorrectionMatrixMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::write(mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::write(mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::write(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::write(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::write(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::write(std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIColorTwistInputCorrectionMatrixMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIColorTwistInputCorrectionMatrixMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIColorTwistInputCorrectionMatrixMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIColorTwistInputCorrectionMatrixMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTColorTwistInputCorrectionMatrixMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *)new std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTColorTwistInputCorrectionMatrixMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTColorTwistInputCorrectionMatrixMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTColorTwistInputCorrectionMatrixMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >(val2); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *)new std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTColorTwistInputCorrectionMatrixMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTColorTwistInputCorrectionMatrixMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTColorTwistInputCorrectionMatrixMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *)new std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >((std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTColorTwistInputCorrectionMatrixMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTColorTwistInputCorrectionMatrixMode", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTColorTwistInputCorrectionMatrixMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTColorTwistInputCorrectionMatrixMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTColorTwistInputCorrectionMatrixMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTColorTwistInputCorrectionMatrixMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::pair(std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >::pair(std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTColorTwistInputCorrectionMatrixMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTColorTwistInputCorrectionMatrixMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorTwistInputCorrectionMatrixMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTColorTwistInputCorrectionMatrixMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTColorTwistInputCorrectionMatrixMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTColorTwistInputCorrectionMatrixMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorTwistInputCorrectionMatrixMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTColorTwistInputCorrectionMatrixMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTColorTwistInputCorrectionMatrixMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorTwistInputCorrectionMatrixMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTColorTwistInputCorrectionMatrixMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTColorTwistInputCorrectionMatrixMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorTwistInputCorrectionMatrixMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTColorTwistInputCorrectionMatrixMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTColorTwistInputCorrectionMatrixMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTColorTwistInputCorrectionMatrixMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTColorTwistInputCorrectionMatrixMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIColorTwistOutputCorrectionMatrixMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIColorTwistOutputCorrectionMatrixMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIColorTwistOutputCorrectionMatrixMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &""'"); }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIColorTwistOutputCorrectionMatrixMode", 0, 1, argv))) SWIG_fail;
  --argc; if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIColorTwistOutputCorrectionMatrixMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorTwistOutputCorrectionMatrixMode_read", 0, 5, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorTwistOutputCorrectionMatrixMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::read(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >(val2); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >* pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorTwistOutputCorrectionMatrixMode_write", 0, 4, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorTwistOutputCorrectionMatrixMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::write(mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::write(mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::write(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::write(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::write(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::write(std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIColorTwistOutputCorrectionMatrixMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIColorTwistOutputCorrectionMatrixMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIColorTwistOutputCorrectionMatrixMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIColorTwistOutputCorrectionMatrixMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTColorTwistOutputCorrectionMatrixMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *)new std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTColorTwistOutputCorrectionMatrixMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTColorTwistOutputCorrectionMatrixMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTColorTwistOutputCorrectionMatrixMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >(val2); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *)new std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTColorTwistOutputCorrectionMatrixMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTColorTwistOutputCorrectionMatrixMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTColorTwistOutputCorrectionMatrixMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *)new std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >((std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTColorTwistOutputCorrectionMatrixMode(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTColorTwistOutputCorrectionMatrixMode", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTColorTwistOutputCorrectionMatrixMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTColorTwistOutputCorrectionMatrixMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTColorTwistOutputCorrectionMatrixMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTColorTwistOutputCorrectionMatrixMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::pair(std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >::pair(std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTColorTwistOutputCorrectionMatrixMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTColorTwistOutputCorrectionMatrixMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorTwistOutputCorrectionMatrixMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTColorTwistOutputCorrectionMatrixMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTColorTwistOutputCorrectionMatrixMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTColorTwistOutputCorrectionMatrixMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorTwistOutputCorrectionMatrixMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTColorTwistOutputCorrectionMatrixMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTColorTwistOutputCorrectionMatrixMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorTwistOutputCorrectionMatrixMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTColorTwistOutputCorrectionMatrixMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTColorTwistOutputCorrectionMatrixMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorTwistOutputCorrectionMatrixMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTColorTwistOutputCorrectionMatrixMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTColorTwistOutputCorrectionMatrixMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTColorTwistOutputCorrectionMatrixMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTColorTwistOutputCorrectionMatrixMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIColorProcessingMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIColorProcessingMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIColorProcessingMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIColorProcessingMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIColorProcessingMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIColorProcessingMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIColorProcessingMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIColorProcessingMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIColorProcessingMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIColorProcessingMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIColorProcessingMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIColorProcessingMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIColorProcessingMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TColorProcessingMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TColorProcessingMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TColorProcessingMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TColorProcessingMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TColorProcessingMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorProcessingMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorProcessingMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorProcessingMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TColorProcessingMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorProcessingMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TColorProcessingMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorProcessingMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorProcessingMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIColorProcessingMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIColorProcessingMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TColorProcessingMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorProcessingMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TColorProcessingMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorProcessingMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorProcessingMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorProcessingMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorProcessingMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorProcessingMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorProcessingMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorProcessingMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorProcessingMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIColorProcessingMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorProcessingMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorProcessingMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorProcessingMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorProcessingMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIColorProcessingMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIColorProcessingMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIColorProcessingMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorProcessingMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::read(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::read(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::read(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::read(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::read(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::read(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  mvIMPACT::acquire::TColorProcessingMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorProcessingMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorProcessingMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorProcessingMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorProcessingMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  mvIMPACT::acquire::TColorProcessingMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIColorProcessingMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorProcessingMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorProcessingMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorProcessingMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorProcessingMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIColorProcessingMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIColorProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TColorProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIColorProcessingMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TColorProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TColorProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIColorProcessingMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIColorProcessingMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIColorProcessingMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIColorProcessingMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIColorProcessingMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::write(mvIMPACT::acquire::TColorProcessingMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::write(mvIMPACT::acquire::TColorProcessingMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::write(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::write(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::write(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >::write(std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIColorProcessingMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIColorProcessingMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIColorProcessingMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIColorProcessingMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTColorProcessingMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *)new std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTColorProcessingMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TColorProcessingMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTColorProcessingMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTColorProcessingMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorProcessingMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorProcessingMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *)new std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTColorProcessingMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTColorProcessingMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTColorProcessingMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *)new std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode >((std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTColorProcessingMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTColorProcessingMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTColorProcessingMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTColorProcessingMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTColorProcessingMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTColorProcessingMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode >::pair(std::string,mvIMPACT::acquire::TColorProcessingMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode >::pair(std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTColorProcessingMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTColorProcessingMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorProcessingMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTColorProcessingMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTColorProcessingMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTColorProcessingMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorProcessingMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTColorProcessingMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  mvIMPACT::acquire::TColorProcessingMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTColorProcessingMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorProcessingMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTColorProcessingMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TColorProcessingMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TColorProcessingMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTColorProcessingMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TColorProcessingMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTColorProcessingMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TColorProcessingMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTColorProcessingMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTColorProcessingMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTColorProcessingMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTColorProcessingMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDarkCurrentFilterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDarkCurrentFilterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDarkCurrentFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDarkCurrentFilterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDarkCurrentFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDarkCurrentFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDarkCurrentFilterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDarkCurrentFilterMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDarkCurrentFilterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDarkCurrentFilterMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDarkCurrentFilterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDarkCurrentFilterMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDarkCurrentFilterMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDarkCurrentFilterMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDarkCurrentFilterMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDarkCurrentFilterMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDarkCurrentFilterMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDarkCurrentFilterMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDarkCurrentFilterMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDarkCurrentFilterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDarkCurrentFilterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDarkCurrentFilterMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDarkCurrentFilterMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDarkCurrentFilterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDarkCurrentFilterMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDarkCurrentFilterMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDarkCurrentFilterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDarkCurrentFilterMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDarkCurrentFilterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDarkCurrentFilterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDarkCurrentFilterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDarkCurrentFilterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDarkCurrentFilterMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDarkCurrentFilterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::read(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::read(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::read(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::read(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::read(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::read(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  mvIMPACT::acquire::TDarkCurrentFilterMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDarkCurrentFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDarkCurrentFilterMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  mvIMPACT::acquire::TDarkCurrentFilterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDarkCurrentFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDarkCurrentFilterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDarkCurrentFilterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDarkCurrentFilterMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDarkCurrentFilterMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDarkCurrentFilterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::write(mvIMPACT::acquire::TDarkCurrentFilterMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::write(mvIMPACT::acquire::TDarkCurrentFilterMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::write(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::write(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::write(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >::write(std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDarkCurrentFilterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDarkCurrentFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDarkCurrentFilterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDarkCurrentFilterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDarkCurrentFilterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *)new std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDarkCurrentFilterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDarkCurrentFilterMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDarkCurrentFilterMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDarkCurrentFilterMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDarkCurrentFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDarkCurrentFilterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *)new std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDarkCurrentFilterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDarkCurrentFilterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDarkCurrentFilterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *)new std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode >((std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDarkCurrentFilterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDarkCurrentFilterMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDarkCurrentFilterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDarkCurrentFilterMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDarkCurrentFilterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDarkCurrentFilterMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode >::pair(std::string,mvIMPACT::acquire::TDarkCurrentFilterMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDarkCurrentFilterMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDarkCurrentFilterMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDarkCurrentFilterMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDarkCurrentFilterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDarkCurrentFilterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDarkCurrentFilterMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDarkCurrentFilterMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDarkCurrentFilterMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  mvIMPACT::acquire::TDarkCurrentFilterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDarkCurrentFilterMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDarkCurrentFilterMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDarkCurrentFilterMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDarkCurrentFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDarkCurrentFilterMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDarkCurrentFilterMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDarkCurrentFilterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDarkCurrentFilterMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDarkCurrentFilterMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDarkCurrentFilterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDarkCurrentFilterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDarkCurrentFilterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDarkCurrentFilterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDefectivePixelsFilterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDefectivePixelsFilterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDefectivePixelsFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDefectivePixelsFilterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDefectivePixelsFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDefectivePixelsFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDefectivePixelsFilterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDefectivePixelsFilterMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDefectivePixelsFilterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDefectivePixelsFilterMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDefectivePixelsFilterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDefectivePixelsFilterMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDefectivePixelsFilterMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDefectivePixelsFilterMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDefectivePixelsFilterMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDefectivePixelsFilterMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDefectivePixelsFilterMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDefectivePixelsFilterMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDefectivePixelsFilterMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDefectivePixelsFilterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDefectivePixelsFilterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDefectivePixelsFilterMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDefectivePixelsFilterMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDefectivePixelsFilterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDefectivePixelsFilterMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDefectivePixelsFilterMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDefectivePixelsFilterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDefectivePixelsFilterMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDefectivePixelsFilterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDefectivePixelsFilterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDefectivePixelsFilterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDefectivePixelsFilterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDefectivePixelsFilterMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDefectivePixelsFilterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::read(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::read(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::read(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::read(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::read(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::read(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  mvIMPACT::acquire::TDefectivePixelsFilterMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDefectivePixelsFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDefectivePixelsFilterMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  mvIMPACT::acquire::TDefectivePixelsFilterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDefectivePixelsFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDefectivePixelsFilterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >* pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDefectivePixelsFilterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDefectivePixelsFilterMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDefectivePixelsFilterMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDefectivePixelsFilterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::write(mvIMPACT::acquire::TDefectivePixelsFilterMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::write(mvIMPACT::acquire::TDefectivePixelsFilterMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::write(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::write(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::write(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >::write(std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDefectivePixelsFilterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDefectivePixelsFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDefectivePixelsFilterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDefectivePixelsFilterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDefectivePixelsFilterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *)new std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDefectivePixelsFilterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDefectivePixelsFilterMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDefectivePixelsFilterMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDefectivePixelsFilterMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDefectivePixelsFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDefectivePixelsFilterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *)new std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDefectivePixelsFilterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDefectivePixelsFilterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDefectivePixelsFilterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *)new std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode >((std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDefectivePixelsFilterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDefectivePixelsFilterMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDefectivePixelsFilterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDefectivePixelsFilterMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDefectivePixelsFilterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDefectivePixelsFilterMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode >::pair(std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDefectivePixelsFilterMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDefectivePixelsFilterMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDefectivePixelsFilterMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDefectivePixelsFilterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDefectivePixelsFilterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDefectivePixelsFilterMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDefectivePixelsFilterMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDefectivePixelsFilterMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  mvIMPACT::acquire::TDefectivePixelsFilterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDefectivePixelsFilterMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDefectivePixelsFilterMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDefectivePixelsFilterMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDefectivePixelsFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDefectivePixelsFilterMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDefectivePixelsFilterMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDefectivePixelsFilterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDefectivePixelsFilterMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDefectivePixelsFilterMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDefectivePixelsFilterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDefectivePixelsFilterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDefectivePixelsFilterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDefectivePixelsFilterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceAccessMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceAccessMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceAccessMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceAccessMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceAccessMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceAccessMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceAccessMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceAccessMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIDeviceAccessMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIDeviceAccessMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIDeviceAccessMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceAccessMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceAccessMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceAccessMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceAccessMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceAccessMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceAccessMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceAccessMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAccessMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceAccessMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceAccessMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceAccessMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAccessMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceAccessMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceAccessMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceAccessMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceAccessMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceAccessMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceAccessMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceAccessMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceAccessMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceAccessMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceAccessMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceAccessMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAccessMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceAccessMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceAccessMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::read(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::read(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::read(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::read(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::read(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::read(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  mvIMPACT::acquire::TDeviceAccessMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceAccessMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceAccessMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  mvIMPACT::acquire::TDeviceAccessMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceAccessMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceAccessMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAccessMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAccessMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAccessMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAccessMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceAccessMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceAccessMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceAccessMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceAccessMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceAccessMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::write(mvIMPACT::acquire::TDeviceAccessMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::write(mvIMPACT::acquire::TDeviceAccessMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::write(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::write(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::write(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >::write(std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceAccessMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceAccessMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceAccessMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceAccessMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceAccessMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceAccessMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceAccessMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceAccessMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceAccessMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceAccessMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceAccessMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceAccessMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceAccessMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceAccessMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode >((std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceAccessMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceAccessMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceAccessMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceAccessMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceAccessMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceAccessMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode >::pair(std::string,mvIMPACT::acquire::TDeviceAccessMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceAccessMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceAccessMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceAccessMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceAccessMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceAccessMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceAccessMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceAccessMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceAccessMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  mvIMPACT::acquire::TDeviceAccessMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceAccessMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceAccessMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceAccessMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceAccessMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceAccessMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceAccessMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceAccessMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceAccessMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceAccessMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceAccessMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceAccessMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceAccessMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceAccessMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceAdvancedOptions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceAdvancedOptions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceAdvancedOptions" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceAdvancedOptions__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceAdvancedOptions" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceAdvancedOptions" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceAdvancedOptions(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceAdvancedOptions", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDeviceAdvancedOptions__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDeviceAdvancedOptions__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDeviceAdvancedOptions__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceAdvancedOptions'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceAdvancedOptions_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceAdvancedOptions> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceAdvancedOptions> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceAdvancedOptions> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceAdvancedOptions>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceAdvancedOptions>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceAdvancedOptions_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceAdvancedOptions_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceAdvancedOptions result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceAdvancedOptions result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceAdvancedOptions_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceAdvancedOptions_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceAdvancedOptions_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceAdvancedOptions_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceAdvancedOptions result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceAdvancedOptions result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceAdvancedOptions result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceAdvancedOptions result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceAdvancedOptions result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAdvancedOptions_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceAdvancedOptions_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceAdvancedOptions_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::read(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::read(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::read(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::read(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::read(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::read(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  mvIMPACT::acquire::TDeviceAdvancedOptions arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceAdvancedOptions""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceAdvancedOptions >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  mvIMPACT::acquire::TDeviceAdvancedOptions arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceAdvancedOptions""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceAdvancedOptions >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >* pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceAdvancedOptions_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceAdvancedOptions>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceAdvancedOptions_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceAdvancedOptions_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::write(mvIMPACT::acquire::TDeviceAdvancedOptions,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::write(mvIMPACT::acquire::TDeviceAdvancedOptions) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::write(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::write(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::write(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >::write(std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceAdvancedOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceAdvancedOptions" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceAdvancedOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceAdvancedOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceAdvancedOptions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceAdvancedOptions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceAdvancedOptions arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceAdvancedOptions" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceAdvancedOptions" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceAdvancedOptions""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceAdvancedOptions >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceAdvancedOptions__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceAdvancedOptions" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceAdvancedOptions" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions >((std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceAdvancedOptions(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceAdvancedOptions", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceAdvancedOptions__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceAdvancedOptions__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceAdvancedOptions__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceAdvancedOptions'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions >::pair(std::string,mvIMPACT::acquire::TDeviceAdvancedOptions)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceAdvancedOptions_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceAdvancedOptions_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceAdvancedOptions_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceAdvancedOptions_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceAdvancedOptions_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceAdvancedOptions_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceAdvancedOptions_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceAdvancedOptions_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  mvIMPACT::acquire::TDeviceAdvancedOptions arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceAdvancedOptions_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceAdvancedOptions_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceAdvancedOptions_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceAdvancedOptions""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceAdvancedOptions >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceAdvancedOptions_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceAdvancedOptions result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceAdvancedOptions_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceAdvancedOptions) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceAdvancedOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceAdvancedOptions" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceAdvancedOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceAdvancedOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceCapability__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceCapability__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceCapability" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceCapability__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceCapability" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceCapability" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceCapability(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceCapability", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIDeviceCapability__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIDeviceCapability__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIDeviceCapability__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceCapability'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceCapability_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceCapability> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceCapability> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceCapability> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceCapability>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceCapability>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceCapability_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceCapability_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceCapability_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceCapability result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceCapability_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceCapability result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceCapability_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceCapability_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceCapability_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceCapability_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceCapability_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceCapability result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceCapability_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceCapability result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceCapability result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceCapability result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceCapability result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceCapability_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceCapability_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceCapability_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceCapability_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceCapability_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceCapability_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceCapability_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceCapability_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceCapability_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceCapability_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceCapability_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceCapability_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceCapability_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceCapability_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::read(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::read(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::read(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::read(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::read(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::read(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  mvIMPACT::acquire::TDeviceCapability arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceCapability_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceCapability""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceCapability >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceCapability_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  mvIMPACT::acquire::TDeviceCapability arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceCapability_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceCapability""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceCapability >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceCapability_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceCapability_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceCapability_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceCapability_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceCapability >* pV = new std::vector<mvIMPACT::acquire::TDeviceCapability > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceCapability_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceCapability >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceCapability>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceCapability_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceCapability_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceCapability_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceCapability_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceCapability_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceCapability_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::write(mvIMPACT::acquire::TDeviceCapability,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::write(mvIMPACT::acquire::TDeviceCapability) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::write(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::write(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::write(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >::write(std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceCapability" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceCapability_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceCapability_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceCapability__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceCapability >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceCapability__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceCapability arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceCapability" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceCapability" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceCapability""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceCapability >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceCapability >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceCapability__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceCapability" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceCapability" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceCapability >((std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceCapability(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceCapability", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceCapability__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceCapability__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceCapability__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceCapability'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceCapability >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceCapability >::pair(std::string,mvIMPACT::acquire::TDeviceCapability)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceCapability >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceCapability_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceCapability_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceCapability_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceCapability_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceCapability_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceCapability_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceCapability_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceCapability_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  mvIMPACT::acquire::TDeviceCapability arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceCapability_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceCapability_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceCapability_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceCapability""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceCapability >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceCapability_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceCapability result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceCapability_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceCapability) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceCapability" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceCapability_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceCapability_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceClass__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceClass__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceClass" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceClass__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceClass" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceClass" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceClass(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceClass", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIDeviceClass__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIDeviceClass__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIDeviceClass__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceClass'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceClass >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceClass_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceClass> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceClass> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceClass> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceClass>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceClass>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceClass_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceClass_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceClass_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceClass_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceClass result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceClass_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceClass result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceClass_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceClass_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceClass_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceClass_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceClass_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceClass result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceClass_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceClass result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceClass result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceClass result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceClass result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceClass_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceClass_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceClass_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceClass_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceClass_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceClass_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceClass_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceClass_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceClass_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceClass_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceClass_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceClass_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceClass_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceClass_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::read(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::read(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::read(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::read(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::read(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::read(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  mvIMPACT::acquire::TDeviceClass arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceClass_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceClass""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceClass >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceClass_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  mvIMPACT::acquire::TDeviceClass arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceClass_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceClass""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceClass >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceClass_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceClass_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceClass_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceClass_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceClass >* pV = new std::vector<mvIMPACT::acquire::TDeviceClass > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceClass_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceClass >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceClass>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceClass_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceClass_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceClass_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceClass_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceClass_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceClass_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::write(mvIMPACT::acquire::TDeviceClass,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::write(mvIMPACT::acquire::TDeviceClass) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::write(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::write(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::write(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >::write(std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceClass" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceClass_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceClass_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceClass__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceClass >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceClass__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceClass arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceClass" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceClass" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceClass""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceClass >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceClass >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceClass__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceClass" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceClass > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceClass" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceClass > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceClass >((std::pair< std::string,mvIMPACT::acquire::TDeviceClass > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceClass(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceClass", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTDeviceClass__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceClass__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceClass__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceClass'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceClass >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceClass >::pair(std::string,mvIMPACT::acquire::TDeviceClass)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceClass >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceClass > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceClass_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceClass_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceClass_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceClass_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceClass_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceClass_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceClass_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceClass_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *) 0 ;
  mvIMPACT::acquire::TDeviceClass arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceClass_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceClass_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceClass_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceClass""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceClass >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceClass_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceClass result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceClass_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceClass) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceClass" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceClass_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceClass_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceDigitalOutputMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceDigitalOutputMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceDigitalOutputMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceDigitalOutputMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceDigitalOutputMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceDigitalOutputMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceDigitalOutputMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceDigitalOutputMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDeviceDigitalOutputMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDeviceDigitalOutputMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDeviceDigitalOutputMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceDigitalOutputMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceDigitalOutputMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceDigitalOutputMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceDigitalOutputMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceDigitalOutputMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceDigitalOutputMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceDigitalOutputMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceDigitalOutputMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceDigitalOutputMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceDigitalOutputMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceDigitalOutputMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceDigitalOutputMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceDigitalOutputMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceDigitalOutputMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceDigitalOutputMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceDigitalOutputMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceDigitalOutputMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceDigitalOutputMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceDigitalOutputMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceDigitalOutputMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceDigitalOutputMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceDigitalOutputMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceDigitalOutputMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::read(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::read(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::read(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::read(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::read(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::read(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  mvIMPACT::acquire::TDeviceDigitalOutputMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceDigitalOutputMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceDigitalOutputMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  mvIMPACT::acquire::TDeviceDigitalOutputMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceDigitalOutputMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceDigitalOutputMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceDigitalOutputMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceDigitalOutputMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceDigitalOutputMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceDigitalOutputMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::write(mvIMPACT::acquire::TDeviceDigitalOutputMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::write(mvIMPACT::acquire::TDeviceDigitalOutputMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::write(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::write(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::write(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >::write(std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceDigitalOutputMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceDigitalOutputMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceDigitalOutputMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceDigitalOutputMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceDigitalOutputMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceDigitalOutputMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceDigitalOutputMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  { std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceDigitalOutputMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceDigitalOutputMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceDigitalOutputMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceDigitalOutputMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceDigitalOutputMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceDigitalOutputMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceDigitalOutputMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode >((std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceDigitalOutputMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceDigitalOutputMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceDigitalOutputMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceDigitalOutputMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceDigitalOutputMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceDigitalOutputMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode >::pair(std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceDigitalOutputMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceDigitalOutputMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceDigitalOutputMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceDigitalOutputMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceDigitalOutputMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceDigitalOutputMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceDigitalOutputMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceDigitalOutputMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  mvIMPACT::acquire::TDeviceDigitalOutputMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceDigitalOutputMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceDigitalOutputMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceDigitalOutputMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceDigitalOutputMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceDigitalOutputMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceDigitalOutputMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceDigitalOutputMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceDigitalOutputMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceDigitalOutputMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceDigitalOutputMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceDigitalOutputMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceDigitalOutputMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceDigitalOutputMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceImageTrigger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceImageTrigger__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceImageTrigger" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceImageTrigger__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceImageTrigger" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceImageTrigger" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceImageTrigger(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceImageTrigger", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDeviceImageTrigger__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDeviceImageTrigger__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDeviceImageTrigger__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceImageTrigger'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceImageTrigger_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceImageTrigger> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceImageTrigger> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceImageTrigger> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceImageTrigger>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceImageTrigger>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceImageTrigger_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceImageTrigger_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceImageTrigger_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceImageTrigger result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceImageTrigger_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceImageTrigger result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceImageTrigger_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceImageTrigger_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceImageTrigger_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceImageTrigger_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceImageTrigger result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceImageTrigger result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceImageTrigger result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceImageTrigger result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceImageTrigger result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceImageTrigger_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceImageTrigger_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceImageTrigger_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::read(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::read(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::read(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::read(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::read(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::read(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  mvIMPACT::acquire::TDeviceImageTrigger arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceImageTrigger""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceImageTrigger >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  mvIMPACT::acquire::TDeviceImageTrigger arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceImageTrigger""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceImageTrigger >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger >* pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceImageTrigger_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceImageTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceImageTrigger>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceImageTrigger_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceImageTrigger_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceImageTrigger_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceImageTrigger_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceImageTrigger_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::write(mvIMPACT::acquire::TDeviceImageTrigger,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::write(mvIMPACT::acquire::TDeviceImageTrigger) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::write(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::write(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::write(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >::write(std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceImageTrigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceImageTrigger" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceImageTrigger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceImageTrigger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceImageTrigger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceImageTrigger__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceImageTrigger arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceImageTrigger" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceImageTrigger" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceImageTrigger""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceImageTrigger >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceImageTrigger__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceImageTrigger" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceImageTrigger" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger >((std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceImageTrigger(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceImageTrigger", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceImageTrigger__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceImageTrigger__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceImageTrigger__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceImageTrigger'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger >::pair(std::string,mvIMPACT::acquire::TDeviceImageTrigger)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceImageTrigger_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceImageTrigger_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceImageTrigger_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceImageTrigger_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceImageTrigger_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceImageTrigger_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceImageTrigger_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceImageTrigger_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  mvIMPACT::acquire::TDeviceImageTrigger arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceImageTrigger_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceImageTrigger_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceImageTrigger_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceImageTrigger""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceImageTrigger >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceImageTrigger_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceImageTrigger result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceImageTrigger_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceImageTrigger) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceImageTrigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceImageTrigger" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceImageTrigger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceImageTrigger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceInterfaceLayout__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceInterfaceLayout__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceInterfaceLayout" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceInterfaceLayout__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceInterfaceLayout" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceInterfaceLayout" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceInterfaceLayout(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceInterfaceLayout", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDeviceInterfaceLayout__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDeviceInterfaceLayout__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDeviceInterfaceLayout__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceInterfaceLayout'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceInterfaceLayout_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceInterfaceLayout> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceInterfaceLayout> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceInterfaceLayout> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceInterfaceLayout>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceInterfaceLayout>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceInterfaceLayout_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceInterfaceLayout_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceInterfaceLayout result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceInterfaceLayout result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceInterfaceLayout_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceInterfaceLayout_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceInterfaceLayout_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceInterfaceLayout_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceInterfaceLayout result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceInterfaceLayout result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceInterfaceLayout result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceInterfaceLayout result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceInterfaceLayout result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceInterfaceLayout_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceInterfaceLayout_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceInterfaceLayout_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::read(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::read(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::read(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::read(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::read(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::read(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  mvIMPACT::acquire::TDeviceInterfaceLayout arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceInterfaceLayout""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceInterfaceLayout >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  mvIMPACT::acquire::TDeviceInterfaceLayout arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceInterfaceLayout""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceInterfaceLayout >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >* pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceInterfaceLayout_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceInterfaceLayout>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceInterfaceLayout_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceInterfaceLayout_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::write(mvIMPACT::acquire::TDeviceInterfaceLayout,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::write(mvIMPACT::acquire::TDeviceInterfaceLayout) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::write(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::write(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::write(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >::write(std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceInterfaceLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceInterfaceLayout" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceInterfaceLayout_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceInterfaceLayout_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceInterfaceLayout__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceInterfaceLayout__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceInterfaceLayout arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceInterfaceLayout" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceInterfaceLayout" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceInterfaceLayout""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceInterfaceLayout >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceInterfaceLayout__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceInterfaceLayout" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceInterfaceLayout" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout >((std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceInterfaceLayout(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceInterfaceLayout", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceInterfaceLayout__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceInterfaceLayout__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceInterfaceLayout__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceInterfaceLayout'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout >::pair(std::string,mvIMPACT::acquire::TDeviceInterfaceLayout)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceInterfaceLayout_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceInterfaceLayout_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceInterfaceLayout_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceInterfaceLayout_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceInterfaceLayout_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceInterfaceLayout_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceInterfaceLayout_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceInterfaceLayout_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  mvIMPACT::acquire::TDeviceInterfaceLayout arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceInterfaceLayout_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceInterfaceLayout_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceInterfaceLayout_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceInterfaceLayout""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceInterfaceLayout >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceInterfaceLayout_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceInterfaceLayout result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceInterfaceLayout_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceInterfaceLayout) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceInterfaceLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceInterfaceLayout" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceInterfaceLayout_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceInterfaceLayout_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceLoadSettings__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceLoadSettings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceLoadSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceLoadSettings__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceLoadSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceLoadSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceLoadSettings(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceLoadSettings", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDeviceLoadSettings__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDeviceLoadSettings__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDeviceLoadSettings__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceLoadSettings'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceLoadSettings_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceLoadSettings> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceLoadSettings> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceLoadSettings> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceLoadSettings>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceLoadSettings>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceLoadSettings_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceLoadSettings_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceLoadSettings_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceLoadSettings result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceLoadSettings_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceLoadSettings result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceLoadSettings_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceLoadSettings_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceLoadSettings_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceLoadSettings_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceLoadSettings result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceLoadSettings result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceLoadSettings result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceLoadSettings result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceLoadSettings result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceLoadSettings_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceLoadSettings_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceLoadSettings_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::read(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::read(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::read(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::read(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::read(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::read(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  mvIMPACT::acquire::TDeviceLoadSettings arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceLoadSettings""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceLoadSettings >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  mvIMPACT::acquire::TDeviceLoadSettings arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceLoadSettings""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceLoadSettings >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings >* pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceLoadSettings_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceLoadSettings >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceLoadSettings>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceLoadSettings_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceLoadSettings_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceLoadSettings_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceLoadSettings_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceLoadSettings_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::write(mvIMPACT::acquire::TDeviceLoadSettings,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::write(mvIMPACT::acquire::TDeviceLoadSettings) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::write(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::write(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::write(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >::write(std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceLoadSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceLoadSettings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceLoadSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceLoadSettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceLoadSettings__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceLoadSettings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceLoadSettings arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceLoadSettings" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceLoadSettings" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceLoadSettings""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceLoadSettings >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceLoadSettings__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceLoadSettings" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceLoadSettings" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings >((std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceLoadSettings(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceLoadSettings", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceLoadSettings__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceLoadSettings__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceLoadSettings__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceLoadSettings'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings >::pair(std::string,mvIMPACT::acquire::TDeviceLoadSettings)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceLoadSettings_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceLoadSettings_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceLoadSettings_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceLoadSettings_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceLoadSettings_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceLoadSettings_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceLoadSettings_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceLoadSettings_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  mvIMPACT::acquire::TDeviceLoadSettings arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceLoadSettings_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceLoadSettings_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceLoadSettings_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceLoadSettings""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceLoadSettings >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceLoadSettings_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceLoadSettings result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceLoadSettings_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceLoadSettings) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceLoadSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceLoadSettings" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceLoadSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceLoadSettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDevicePowerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDevicePowerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDevicePowerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDevicePowerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDevicePowerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDevicePowerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDevicePowerMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDevicePowerMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDevicePowerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIDevicePowerMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIDevicePowerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDevicePowerMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDevicePowerMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDevicePowerMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDevicePowerMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDevicePowerMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDevicePowerMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDevicePowerMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDevicePowerMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDevicePowerMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIDevicePowerMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDevicePowerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDevicePowerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDevicePowerMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDevicePowerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDevicePowerMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIDevicePowerMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDevicePowerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDevicePowerMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDevicePowerMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDevicePowerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDevicePowerMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDevicePowerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDevicePowerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDevicePowerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDevicePowerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDevicePowerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDevicePowerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDevicePowerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDevicePowerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDevicePowerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDevicePowerMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDevicePowerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDevicePowerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDevicePowerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDevicePowerMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDevicePowerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDevicePowerMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDevicePowerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::read(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::read(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::read(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::read(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::read(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::read(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  mvIMPACT::acquire::TDevicePowerMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDevicePowerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDevicePowerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDevicePowerMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDevicePowerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  mvIMPACT::acquire::TDevicePowerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDevicePowerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDevicePowerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDevicePowerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDevicePowerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDevicePowerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDevicePowerMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDevicePowerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDevicePowerMode >* pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDevicePowerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDevicePowerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDevicePowerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDevicePowerMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDevicePowerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDevicePowerMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDevicePowerMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDevicePowerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::write(mvIMPACT::acquire::TDevicePowerMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::write(mvIMPACT::acquire::TDevicePowerMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::write(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::write(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::write(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >::write(std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDevicePowerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDevicePowerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDevicePowerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDevicePowerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDevicePowerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *)new std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDevicePowerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDevicePowerMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDevicePowerMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDevicePowerMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDevicePowerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDevicePowerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *)new std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDevicePowerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDevicePowerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDevicePowerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *)new std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode >((std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDevicePowerMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDevicePowerMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTDevicePowerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDevicePowerMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDevicePowerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDevicePowerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode >::pair(std::string,mvIMPACT::acquire::TDevicePowerMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDevicePowerMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDevicePowerMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDevicePowerMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDevicePowerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDevicePowerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDevicePowerMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDevicePowerMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDevicePowerMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  mvIMPACT::acquire::TDevicePowerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDevicePowerMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDevicePowerMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDevicePowerMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDevicePowerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDevicePowerMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDevicePowerMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDevicePowerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDevicePowerMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDevicePowerMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDevicePowerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDevicePowerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDevicePowerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDevicePowerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceScanRateMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceScanRateMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceScanRateMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceScanRateMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceScanRateMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceScanRateMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceScanRateMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceScanRateMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDeviceScanRateMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDeviceScanRateMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDeviceScanRateMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceScanRateMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceScanRateMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceScanRateMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceScanRateMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceScanRateMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceScanRateMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceScanRateMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceScanRateMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceScanRateMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceScanRateMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceScanRateMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceScanRateMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceScanRateMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceScanRateMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceScanRateMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceScanRateMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceScanRateMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceScanRateMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceScanRateMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceScanRateMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceScanRateMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceScanRateMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceScanRateMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceScanRateMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceScanRateMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::read(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::read(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::read(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::read(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::read(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::read(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  mvIMPACT::acquire::TDeviceScanRateMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceScanRateMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceScanRateMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  mvIMPACT::acquire::TDeviceScanRateMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceScanRateMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceScanRateMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceScanRateMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceScanRateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceScanRateMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceScanRateMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceScanRateMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceScanRateMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceScanRateMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceScanRateMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::write(mvIMPACT::acquire::TDeviceScanRateMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::write(mvIMPACT::acquire::TDeviceScanRateMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::write(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::write(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::write(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >::write(std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceScanRateMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceScanRateMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceScanRateMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceScanRateMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceScanRateMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceScanRateMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceScanRateMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceScanRateMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceScanRateMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceScanRateMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceScanRateMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceScanRateMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceScanRateMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceScanRateMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode >((std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceScanRateMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceScanRateMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceScanRateMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceScanRateMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceScanRateMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceScanRateMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode >::pair(std::string,mvIMPACT::acquire::TDeviceScanRateMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceScanRateMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceScanRateMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceScanRateMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceScanRateMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceScanRateMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceScanRateMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceScanRateMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceScanRateMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  mvIMPACT::acquire::TDeviceScanRateMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceScanRateMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceScanRateMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceScanRateMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceScanRateMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceScanRateMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceScanRateMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceScanRateMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceScanRateMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceScanRateMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceScanRateMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceScanRateMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceScanRateMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceScanRateMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceSignalOutputStartEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceSignalOutputStartEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceSignalOutputStartEvent" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceSignalOutputStartEvent__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceSignalOutputStartEvent" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceSignalOutputStartEvent" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceSignalOutputStartEvent(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceSignalOutputStartEvent", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDeviceSignalOutputStartEvent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDeviceSignalOutputStartEvent__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDeviceSignalOutputStartEvent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceSignalOutputStartEvent'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceSignalOutputStartEvent_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceSignalOutputStartEvent> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceSignalOutputStartEvent> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceSignalOutputStartEvent> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceSignalOutputStartEvent>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceSignalOutputStartEvent>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceSignalOutputStartEvent_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceSignalOutputStartEvent_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TDeviceSignalOutputStartEvent result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceSignalOutputStartEvent result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceSignalOutputStartEvent_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TDeviceSignalOutputStartEvent result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceSignalOutputStartEvent result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceSignalOutputStartEvent result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceSignalOutputStartEvent result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceSignalOutputStartEvent result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSignalOutputStartEvent_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceSignalOutputStartEvent_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceSignalOutputStartEvent_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::read(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::read(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::read(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::read(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::read(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::read(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  mvIMPACT::acquire::TDeviceSignalOutputStartEvent arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceSignalOutputStartEvent""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  mvIMPACT::acquire::TDeviceSignalOutputStartEvent arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceSignalOutputStartEvent""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >* pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSignalOutputStartEvent_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceSignalOutputStartEvent_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceSignalOutputStartEvent_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::write(mvIMPACT::acquire::TDeviceSignalOutputStartEvent,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::write(mvIMPACT::acquire::TDeviceSignalOutputStartEvent) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::write(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::write(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::write(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::write(std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceSignalOutputStartEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceSignalOutputStartEvent" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceSignalOutputStartEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceSignalOutputStartEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceSignalOutputStartEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceSignalOutputStartEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceSignalOutputStartEvent arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceSignalOutputStartEvent" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceSignalOutputStartEvent" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceSignalOutputStartEvent""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceSignalOutputStartEvent__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceSignalOutputStartEvent" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceSignalOutputStartEvent" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent >((std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceSignalOutputStartEvent(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceSignalOutputStartEvent", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceSignalOutputStartEvent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceSignalOutputStartEvent__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceSignalOutputStartEvent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceSignalOutputStartEvent'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::pair(std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceSignalOutputStartEvent_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceSignalOutputStartEvent_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceSignalOutputStartEvent_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceSignalOutputStartEvent_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceSignalOutputStartEvent_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceSignalOutputStartEvent_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceSignalOutputStartEvent_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceSignalOutputStartEvent_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  mvIMPACT::acquire::TDeviceSignalOutputStartEvent arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceSignalOutputStartEvent_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceSignalOutputStartEvent_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceSignalOutputStartEvent_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceSignalOutputStartEvent""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceSignalOutputStartEvent_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceSignalOutputStartEvent result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceSignalOutputStartEvent_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceSignalOutputStartEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceSignalOutputStartEvent" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceSignalOutputStartEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceSignalOutputStartEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceState__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceState" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceState__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceState" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceState" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceState(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceState", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIDeviceState__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIDeviceState__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIDeviceState__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceState'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceState >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceState > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceState_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceState> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceState> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceState> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceState>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceState>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceState_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceState_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceState_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceState_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceState_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceState result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceState_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceState result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceState_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceState_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceState_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceState_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceState_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceState_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceState result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceState_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceState result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceState_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceState_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceState_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceState_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceState_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceState_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceState_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceState_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceState_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceState_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceState_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceState_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceState_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceState_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceState_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceState_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceState_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceState_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceState_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::read(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::read(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::read(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::read(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::read(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::read(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  mvIMPACT::acquire::TDeviceState arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceState_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceState >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceState_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  mvIMPACT::acquire::TDeviceState arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceState_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceState >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceState_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceState_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceState_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceState >* pV = new std::vector<mvIMPACT::acquire::TDeviceState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceState_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceState_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceState_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceState_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceState_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceState_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceState_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceState_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceState_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::write(mvIMPACT::acquire::TDeviceState,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::write(mvIMPACT::acquire::TDeviceState) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::write(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::write(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::write(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >::write(std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceState" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceState > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceState > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceState >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceState__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceState arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceState > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceState" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceState" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceState >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceState > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceState >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceState__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceState > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceState > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceState > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceState > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceState" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceState > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceState" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceState > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceState > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceState >((std::pair< std::string,mvIMPACT::acquire::TDeviceState > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceState(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceState", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTDeviceState__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceState__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceState__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceState'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceState >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceState >::pair(std::string,mvIMPACT::acquire::TDeviceState)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceState >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceState > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceState_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceState > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceState_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceState_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceState > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceState_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceState_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceState_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceState_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceState > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceState_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceState > *) 0 ;
  mvIMPACT::acquire::TDeviceState arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceState_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceState_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceState_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceState >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceState_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceState_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceState > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceState) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceState" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceSyncOutMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceSyncOutMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceSyncOutMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceSyncOutMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceSyncOutMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceSyncOutMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceSyncOutMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceSyncOutMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIDeviceSyncOutMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIDeviceSyncOutMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIDeviceSyncOutMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceSyncOutMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceSyncOutMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceSyncOutMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceSyncOutMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceSyncOutMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceSyncOutMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceSyncOutMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceSyncOutMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceSyncOutMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceSyncOutMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceSyncOutMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceSyncOutMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceSyncOutMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceSyncOutMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceSyncOutMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceSyncOutMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceSyncOutMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceSyncOutMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceSyncOutMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceSyncOutMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSyncOutMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceSyncOutMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceSyncOutMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::read(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::read(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::read(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::read(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::read(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::read(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  mvIMPACT::acquire::TDeviceSyncOutMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceSyncOutMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceSyncOutMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  mvIMPACT::acquire::TDeviceSyncOutMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceSyncOutMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceSyncOutMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceSyncOutMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceSyncOutMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceSyncOutMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceSyncOutMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceSyncOutMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceSyncOutMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceSyncOutMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceSyncOutMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::write(mvIMPACT::acquire::TDeviceSyncOutMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::write(mvIMPACT::acquire::TDeviceSyncOutMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::write(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::write(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::write(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >::write(std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceSyncOutMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceSyncOutMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceSyncOutMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceSyncOutMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceSyncOutMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceSyncOutMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceSyncOutMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceSyncOutMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceSyncOutMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceSyncOutMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceSyncOutMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceSyncOutMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceSyncOutMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceSyncOutMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode >((std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceSyncOutMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceSyncOutMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceSyncOutMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceSyncOutMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceSyncOutMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceSyncOutMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode >::pair(std::string,mvIMPACT::acquire::TDeviceSyncOutMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceSyncOutMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceSyncOutMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceSyncOutMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceSyncOutMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceSyncOutMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceSyncOutMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceSyncOutMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceSyncOutMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  mvIMPACT::acquire::TDeviceSyncOutMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceSyncOutMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceSyncOutMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceSyncOutMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceSyncOutMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceSyncOutMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceSyncOutMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceSyncOutMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceSyncOutMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceSyncOutMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceSyncOutMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceSyncOutMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceSyncOutMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceSyncOutMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceTriggerInterface__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceTriggerInterface__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceTriggerInterface" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceTriggerInterface__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceTriggerInterface" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceTriggerInterface" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceTriggerInterface(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceTriggerInterface", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDeviceTriggerInterface__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDeviceTriggerInterface__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDeviceTriggerInterface__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceTriggerInterface'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerInterface_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceTriggerInterface> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerInterface> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerInterface> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerInterface>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerInterface>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerInterface_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceTriggerInterface_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceTriggerInterface result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceTriggerInterface result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerInterface_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceTriggerInterface_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerInterface_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerInterface_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceTriggerInterface result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceTriggerInterface result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerInterface result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerInterface result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerInterface result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerInterface_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerInterface_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceTriggerInterface_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  mvIMPACT::acquire::TDeviceTriggerInterface arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerInterface""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerInterface >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  mvIMPACT::acquire::TDeviceTriggerInterface arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerInterface""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerInterface >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerInterface_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerInterface >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerInterface>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerInterface_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceTriggerInterface_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceTriggerInterface_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerInterface_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceTriggerInterface_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::write(mvIMPACT::acquire::TDeviceTriggerInterface,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::write(mvIMPACT::acquire::TDeviceTriggerInterface) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceTriggerInterface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceTriggerInterface" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceTriggerInterface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceTriggerInterface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerInterface__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerInterface__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceTriggerInterface arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceTriggerInterface" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceTriggerInterface" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerInterface""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerInterface >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerInterface__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceTriggerInterface" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceTriggerInterface" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface >((std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerInterface(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceTriggerInterface", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceTriggerInterface__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceTriggerInterface__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceTriggerInterface__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceTriggerInterface'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface >::pair(std::string,mvIMPACT::acquire::TDeviceTriggerInterface)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerInterface_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceTriggerInterface_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerInterface_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceTriggerInterface_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceTriggerInterface_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerInterface_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerInterface_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerInterface_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  mvIMPACT::acquire::TDeviceTriggerInterface arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceTriggerInterface_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerInterface_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceTriggerInterface_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerInterface""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerInterface >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerInterface_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerInterface result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerInterface_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceTriggerInterface) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceTriggerInterface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceTriggerInterface" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceTriggerInterface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceTriggerInterface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceTriggerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceTriggerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDeviceTriggerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceTriggerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDeviceTriggerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDeviceTriggerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceTriggerMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDeviceTriggerMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIDeviceTriggerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIDeviceTriggerMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIDeviceTriggerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDeviceTriggerMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceTriggerMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceTriggerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceTriggerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceTriggerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceTriggerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceTriggerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceTriggerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceTriggerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  mvIMPACT::acquire::TDeviceTriggerMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  mvIMPACT::acquire::TDeviceTriggerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceTriggerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDeviceTriggerMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceTriggerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceTriggerMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDeviceTriggerMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDeviceTriggerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::write(mvIMPACT::acquire::TDeviceTriggerMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::write(mvIMPACT::acquire::TDeviceTriggerMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceTriggerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceTriggerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceTriggerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDeviceTriggerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceTriggerMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceTriggerMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceTriggerMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceTriggerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceTriggerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode >((std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceTriggerMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceTriggerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceTriggerMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceTriggerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceTriggerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode >::pair(std::string,mvIMPACT::acquire::TDeviceTriggerMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceTriggerMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceTriggerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceTriggerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  mvIMPACT::acquire::TDeviceTriggerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceTriggerMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceTriggerMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceTriggerMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceTriggerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceTriggerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceTriggerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceTriggerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDigIOState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigIOState__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDigIOState" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigIOState__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDigIOState" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDigIOState" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigIOState(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDigIOState", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIDigIOState__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIDigIOState__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIDigIOState__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDigIOState'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDigIOState >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigIOState > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigIOState_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDigIOState> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDigIOState> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDigIOState> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDigIOState>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDigIOState>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigIOState_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigIOState_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDigIOState_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigIOState_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigIOState_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigIOState result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigIOState_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigIOState result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigIOState_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDigIOState_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigIOState_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigIOState_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigIOState_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigIOState_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigIOState result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigIOState_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigIOState result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigIOState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigIOState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigIOState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigIOState_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigIOState_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigIOState_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigIOState_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigIOState_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDigIOState_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigIOState_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigIOState_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigIOState_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigIOState_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDigIOState_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigIOState_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigIOState_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigIOState_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigIOState_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDigIOState_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigIOState_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDigIOState_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigIOState_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::read(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::read(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::read(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::read(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::read(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::read(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  mvIMPACT::acquire::TDigIOState arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigIOState_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigIOState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigIOState >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigIOState_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  mvIMPACT::acquire::TDigIOState arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigIOState_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigIOState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigIOState >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigIOState_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigIOState_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigIOState_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigIOState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigIOState >* pV = new std::vector<mvIMPACT::acquire::TDigIOState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigIOState_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigIOState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigIOState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigIOState_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigIOState_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigIOState_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIDigIOState_write__SWIG_5(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDigIOState_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigIOState_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigIOState_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigIOState_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::write(mvIMPACT::acquire::TDigIOState,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::write(mvIMPACT::acquire::TDigIOState) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::write(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::write(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::write(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >::write(std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDigIOState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDigIOState" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDigIOState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDigIOState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDigIOState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigIOState > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigIOState > *)new std::pair< std::string,mvIMPACT::acquire::TDigIOState >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigIOState__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDigIOState arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDigIOState > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDigIOState" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDigIOState" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigIOState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigIOState >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigIOState > *)new std::pair< std::string,mvIMPACT::acquire::TDigIOState >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigIOState__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigIOState > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDigIOState > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDigIOState > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDigIOState > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDigIOState" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigIOState > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDigIOState" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigIOState > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigIOState > *)new std::pair< std::string,mvIMPACT::acquire::TDigIOState >((std::pair< std::string,mvIMPACT::acquire::TDigIOState > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigIOState(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDigIOState", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTDigIOState__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDigIOState__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDigIOState__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDigIOState'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDigIOState >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigIOState >::pair(std::string,mvIMPACT::acquire::TDigIOState)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigIOState >::pair(std::pair< std::string,mvIMPACT::acquire::TDigIOState > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDigIOState_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigIOState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigIOState > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigIOState_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigIOState_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigIOState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigIOState > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDigIOState_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDigIOState_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigIOState_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigIOState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigIOState_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigIOState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigIOState > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigIOState_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigIOState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigIOState > *) 0 ;
  mvIMPACT::acquire::TDigIOState arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigIOState_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigIOState_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigIOState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigIOState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDigIOState_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigIOState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigIOState >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigIOState_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigIOState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigIOState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigIOState_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigIOState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigIOState > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDigIOState) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDigIOState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigIOState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigIOState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDigIOState" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigIOState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigIOState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDigIOState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDigIOState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDigitalIOMeasurementMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalIOMeasurementMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDigitalIOMeasurementMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalIOMeasurementMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDigitalIOMeasurementMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDigitalIOMeasurementMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalIOMeasurementMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDigitalIOMeasurementMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDigitalIOMeasurementMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDigitalIOMeasurementMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDigitalIOMeasurementMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDigitalIOMeasurementMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDigitalIOMeasurementMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalIOMeasurementMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigitalIOMeasurementMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigitalIOMeasurementMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalIOMeasurementMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigitalIOMeasurementMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigitalIOMeasurementMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalIOMeasurementMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalIOMeasurementMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalIOMeasurementMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalIOMeasurementMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  mvIMPACT::acquire::TDigitalIOMeasurementMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalIOMeasurementMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalIOMeasurementMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  mvIMPACT::acquire::TDigitalIOMeasurementMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalIOMeasurementMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalIOMeasurementMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalIOMeasurementMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::write(mvIMPACT::acquire::TDigitalIOMeasurementMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::write(mvIMPACT::acquire::TDigitalIOMeasurementMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::write(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::write(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::write(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >::write(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDigitalIOMeasurementMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDigitalIOMeasurementMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDigitalIOMeasurementMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDigitalIOMeasurementMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDigitalIOMeasurementMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalIOMeasurementMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDigitalIOMeasurementMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  { std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDigitalIOMeasurementMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDigitalIOMeasurementMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalIOMeasurementMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalIOMeasurementMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalIOMeasurementMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDigitalIOMeasurementMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDigitalIOMeasurementMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode >((std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalIOMeasurementMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDigitalIOMeasurementMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDigitalIOMeasurementMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDigitalIOMeasurementMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDigitalIOMeasurementMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDigitalIOMeasurementMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode >::pair(std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalIOMeasurementMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigitalIOMeasurementMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalIOMeasurementMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDigitalIOMeasurementMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDigitalIOMeasurementMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalIOMeasurementMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalIOMeasurementMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalIOMeasurementMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  mvIMPACT::acquire::TDigitalIOMeasurementMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigitalIOMeasurementMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalIOMeasurementMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDigitalIOMeasurementMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalIOMeasurementMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalIOMeasurementMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalIOMeasurementMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalIOMeasurementMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalIOMeasurementMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDigitalIOMeasurementMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDigitalIOMeasurementMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDigitalIOMeasurementMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDigitalIOMeasurementMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDigitalIOMeasurementMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDigitalIOMeasurementSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalIOMeasurementSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDigitalIOMeasurementSource" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalIOMeasurementSource__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDigitalIOMeasurementSource" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDigitalIOMeasurementSource" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalIOMeasurementSource(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDigitalIOMeasurementSource", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDigitalIOMeasurementSource__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDigitalIOMeasurementSource__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDigitalIOMeasurementSource__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDigitalIOMeasurementSource'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementSource_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDigitalIOMeasurementSource> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementSource> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementSource> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementSource>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDigitalIOMeasurementSource>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementSource_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalIOMeasurementSource_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigitalIOMeasurementSource result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigitalIOMeasurementSource result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementSource_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalIOMeasurementSource_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementSource_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementSource_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigitalIOMeasurementSource result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigitalIOMeasurementSource result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalIOMeasurementSource result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalIOMeasurementSource result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalIOMeasurementSource result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementSource_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementSource_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalIOMeasurementSource_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::read(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  mvIMPACT::acquire::TDigitalIOMeasurementSource arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalIOMeasurementSource""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalIOMeasurementSource >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  mvIMPACT::acquire::TDigitalIOMeasurementSource arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalIOMeasurementSource""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalIOMeasurementSource >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >* pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalIOMeasurementSource_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalIOMeasurementSource>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalIOMeasurementSource_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalIOMeasurementSource_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::write(mvIMPACT::acquire::TDigitalIOMeasurementSource,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::write(mvIMPACT::acquire::TDigitalIOMeasurementSource) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::write(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::write(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::write(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >::write(std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDigitalIOMeasurementSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDigitalIOMeasurementSource" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDigitalIOMeasurementSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDigitalIOMeasurementSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDigitalIOMeasurementSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalIOMeasurementSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDigitalIOMeasurementSource arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDigitalIOMeasurementSource" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDigitalIOMeasurementSource" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalIOMeasurementSource""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalIOMeasurementSource >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalIOMeasurementSource__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDigitalIOMeasurementSource" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDigitalIOMeasurementSource" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource >((std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalIOMeasurementSource(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDigitalIOMeasurementSource", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDigitalIOMeasurementSource__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDigitalIOMeasurementSource__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDigitalIOMeasurementSource__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDigitalIOMeasurementSource'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource >::pair(std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource >::pair(std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalIOMeasurementSource_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigitalIOMeasurementSource_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalIOMeasurementSource_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDigitalIOMeasurementSource_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDigitalIOMeasurementSource_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalIOMeasurementSource_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalIOMeasurementSource_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalIOMeasurementSource_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  mvIMPACT::acquire::TDigitalIOMeasurementSource arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigitalIOMeasurementSource_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalIOMeasurementSource_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDigitalIOMeasurementSource_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalIOMeasurementSource""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalIOMeasurementSource >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalIOMeasurementSource_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalIOMeasurementSource result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalIOMeasurementSource_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDigitalIOMeasurementSource) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDigitalIOMeasurementSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDigitalIOMeasurementSource" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDigitalIOMeasurementSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDigitalIOMeasurementSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDigitalOutputControlMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalOutputControlMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDigitalOutputControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalOutputControlMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDigitalOutputControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDigitalOutputControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalOutputControlMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDigitalOutputControlMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIDigitalOutputControlMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIDigitalOutputControlMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIDigitalOutputControlMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDigitalOutputControlMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalOutputControlMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDigitalOutputControlMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDigitalOutputControlMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDigitalOutputControlMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDigitalOutputControlMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDigitalOutputControlMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalOutputControlMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalOutputControlMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigitalOutputControlMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigitalOutputControlMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalOutputControlMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalOutputControlMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalOutputControlMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalOutputControlMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigitalOutputControlMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigitalOutputControlMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalOutputControlMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalOutputControlMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalOutputControlMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalOutputControlMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalOutputControlMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalOutputControlMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::read(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::read(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::read(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::read(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::read(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::read(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  mvIMPACT::acquire::TDigitalOutputControlMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalOutputControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalOutputControlMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  mvIMPACT::acquire::TDigitalOutputControlMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalOutputControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalOutputControlMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >* pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalOutputControlMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalOutputControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalOutputControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalOutputControlMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigitalOutputControlMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDigitalOutputControlMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigitalOutputControlMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalOutputControlMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::write(mvIMPACT::acquire::TDigitalOutputControlMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::write(mvIMPACT::acquire::TDigitalOutputControlMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::write(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::write(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::write(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >::write(std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDigitalOutputControlMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDigitalOutputControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDigitalOutputControlMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDigitalOutputControlMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDigitalOutputControlMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalOutputControlMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDigitalOutputControlMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  { std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDigitalOutputControlMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDigitalOutputControlMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalOutputControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalOutputControlMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalOutputControlMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDigitalOutputControlMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDigitalOutputControlMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode >((std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalOutputControlMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDigitalOutputControlMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDigitalOutputControlMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDigitalOutputControlMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDigitalOutputControlMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDigitalOutputControlMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode >::pair(std::string,mvIMPACT::acquire::TDigitalOutputControlMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode >::pair(std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalOutputControlMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigitalOutputControlMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalOutputControlMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDigitalOutputControlMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDigitalOutputControlMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalOutputControlMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalOutputControlMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalOutputControlMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  mvIMPACT::acquire::TDigitalOutputControlMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigitalOutputControlMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalOutputControlMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDigitalOutputControlMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalOutputControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalOutputControlMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalOutputControlMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalOutputControlMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalOutputControlMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDigitalOutputControlMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDigitalOutputControlMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDigitalOutputControlMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDigitalOutputControlMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDigitalOutputControlMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIDigitalSignal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalSignal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIDigitalSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalSignal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIDigitalSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIDigitalSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDigitalSignal(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIDigitalSignal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIDigitalSignal__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIDigitalSignal__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIDigitalSignal__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIDigitalSignal'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalSignal_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDigitalSignal> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDigitalSignal> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDigitalSignal> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDigitalSignal>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDigitalSignal>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalSignal_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalSignal_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDigitalSignal_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalSignal_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalSignal_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigitalSignal result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalSignal_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigitalSignal result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalSignal_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDigitalSignal_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalSignal_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalSignal_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalSignal_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIDigitalSignal_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDigitalSignal result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalSignal_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDigitalSignal result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalSignal result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalSignal result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalSignal result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalSignal_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalSignal_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalSignal_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalSignal_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalSignal_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIDigitalSignal_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalSignal_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalSignal_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalSignal_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalSignal_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIDigitalSignal_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigitalSignal_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalSignal_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalSignal_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigitalSignal_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIDigitalSignal_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigitalSignal_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIDigitalSignal_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalSignal_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::read(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::read(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::read(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::read(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::read(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::read(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  mvIMPACT::acquire::TDigitalSignal arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalSignal_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalSignal""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalSignal >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalSignal_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  mvIMPACT::acquire::TDigitalSignal arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDigitalSignal_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalSignal""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalSignal >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalSignal_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalSignal_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIDigitalSignal_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDigitalSignal_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDigitalSignal >* pV = new std::vector<mvIMPACT::acquire::TDigitalSignal > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDigitalSignal_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDigitalSignal >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDigitalSignal>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIDigitalSignal_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigitalSignal_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIDigitalSignal_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDigitalSignal_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIDigitalSignal_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIDigitalSignal_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIDigitalSignal_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIDigitalSignal_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::write(mvIMPACT::acquire::TDigitalSignal,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::write(mvIMPACT::acquire::TDigitalSignal) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::write(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::write(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::write(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >::write(std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDigitalSignal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDigitalSignal" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDigitalSignal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIDigitalSignal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDigitalSignal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalSignal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDigitalSignal arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDigitalSignal" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDigitalSignal" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalSignal""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalSignal >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalSignal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDigitalSignal" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDigitalSignal" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *)new std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >((std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDigitalSignal(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDigitalSignal", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDigitalSignal__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDigitalSignal__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDigitalSignal__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDigitalSignal'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >::pair(std::string,mvIMPACT::acquire::TDigitalSignal)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >::pair(std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalSignal_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigitalSignal_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalSignal_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDigitalSignal_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDigitalSignal_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalSignal_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalSignal_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalSignal_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  mvIMPACT::acquire::TDigitalSignal arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDigitalSignal_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalSignal_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDigitalSignal_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDigitalSignal""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDigitalSignal >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDigitalSignal_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDigitalSignal result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDigitalSignal_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDigitalSignal) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDigitalSignal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDigitalSignal" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDigitalSignal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDigitalSignal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIFieldGateMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIFieldGateMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIFieldGateMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIFieldGateMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIFieldGateMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIFieldGateMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIFieldGateMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIFieldGateMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIFieldGateMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIFieldGateMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIFieldGateMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIFieldGateMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIFieldGateMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TFieldGateMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TFieldGateMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TFieldGateMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TFieldGateMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TFieldGateMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFieldGateMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFieldGateMode_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIFieldGateMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFieldGateMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFieldGateMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TFieldGateMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFieldGateMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TFieldGateMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFieldGateMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIFieldGateMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFieldGateMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFieldGateMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIFieldGateMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIFieldGateMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TFieldGateMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFieldGateMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TFieldGateMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFieldGateMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFieldGateMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFieldGateMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFieldGateMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFieldGateMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFieldGateMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFieldGateMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFieldGateMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIFieldGateMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFieldGateMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFieldGateMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFieldGateMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFieldGateMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIFieldGateMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIFieldGateMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFieldGateMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIFieldGateMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIFieldGateMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIFieldGateMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIFieldGateMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIFieldGateMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFieldGateMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::read(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::read(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::read(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::read(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::read(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::read(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  mvIMPACT::acquire::TFieldGateMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFieldGateMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TFieldGateMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFieldGateMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFieldGateMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  mvIMPACT::acquire::TFieldGateMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFieldGateMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TFieldGateMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFieldGateMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFieldGateMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFieldGateMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFieldGateMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFieldGateMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFieldGateMode >* pV = new std::vector<mvIMPACT::acquire::TFieldGateMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFieldGateMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFieldGateMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFieldGateMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFieldGateMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIFieldGateMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFieldGateMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIFieldGateMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIFieldGateMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIFieldGateMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIFieldGateMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFieldGateMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::write(mvIMPACT::acquire::TFieldGateMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::write(mvIMPACT::acquire::TFieldGateMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::write(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::write(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::write(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >::write(std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIFieldGateMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIFieldGateMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIFieldGateMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIFieldGateMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTFieldGateMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *)new std::pair< std::string,mvIMPACT::acquire::TFieldGateMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTFieldGateMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TFieldGateMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTFieldGateMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTFieldGateMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TFieldGateMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFieldGateMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *)new std::pair< std::string,mvIMPACT::acquire::TFieldGateMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTFieldGateMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTFieldGateMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTFieldGateMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *)new std::pair< std::string,mvIMPACT::acquire::TFieldGateMode >((std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTFieldGateMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTFieldGateMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTFieldGateMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTFieldGateMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTFieldGateMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTFieldGateMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TFieldGateMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TFieldGateMode >::pair(std::string,mvIMPACT::acquire::TFieldGateMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TFieldGateMode >::pair(std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTFieldGateMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTFieldGateMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFieldGateMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTFieldGateMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTFieldGateMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTFieldGateMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFieldGateMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTFieldGateMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  mvIMPACT::acquire::TFieldGateMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTFieldGateMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFieldGateMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTFieldGateMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TFieldGateMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFieldGateMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTFieldGateMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFieldGateMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFieldGateMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TFieldGateMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTFieldGateMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTFieldGateMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTFieldGateMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTFieldGateMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIFlatFieldFilterCorrectionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIFlatFieldFilterCorrectionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIFlatFieldFilterCorrectionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIFlatFieldFilterCorrectionMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIFlatFieldFilterCorrectionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIFlatFieldFilterCorrectionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIFlatFieldFilterCorrectionMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIFlatFieldFilterCorrectionMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIFlatFieldFilterCorrectionMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIFlatFieldFilterCorrectionMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIFlatFieldFilterCorrectionMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIFlatFieldFilterCorrectionMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterCorrectionMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TFlatFieldFilterCorrectionMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TFlatFieldFilterCorrectionMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TFlatFieldFilterCorrectionMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TFlatFieldFilterCorrectionMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFlatFieldFilterCorrectionMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFlatFieldFilterCorrectionMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFlatFieldFilterCorrectionMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterCorrectionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterCorrectionMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFlatFieldFilterCorrectionMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  mvIMPACT::acquire::TFlatFieldFilterCorrectionMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TFlatFieldFilterCorrectionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  mvIMPACT::acquire::TFlatFieldFilterCorrectionMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TFlatFieldFilterCorrectionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterCorrectionMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterCorrectionMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFlatFieldFilterCorrectionMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::write(mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::write(mvIMPACT::acquire::TFlatFieldFilterCorrectionMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::write(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::write(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::write(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::write(std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIFlatFieldFilterCorrectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIFlatFieldFilterCorrectionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIFlatFieldFilterCorrectionMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIFlatFieldFilterCorrectionMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTFlatFieldFilterCorrectionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *)new std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTFlatFieldFilterCorrectionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TFlatFieldFilterCorrectionMode arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTFlatFieldFilterCorrectionMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTFlatFieldFilterCorrectionMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TFlatFieldFilterCorrectionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *)new std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTFlatFieldFilterCorrectionMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTFlatFieldFilterCorrectionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTFlatFieldFilterCorrectionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *)new std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >((std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTFlatFieldFilterCorrectionMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTFlatFieldFilterCorrectionMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTFlatFieldFilterCorrectionMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTFlatFieldFilterCorrectionMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTFlatFieldFilterCorrectionMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTFlatFieldFilterCorrectionMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::pair(std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >::pair(std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTFlatFieldFilterCorrectionMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTFlatFieldFilterCorrectionMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFlatFieldFilterCorrectionMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTFlatFieldFilterCorrectionMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTFlatFieldFilterCorrectionMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTFlatFieldFilterCorrectionMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFlatFieldFilterCorrectionMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTFlatFieldFilterCorrectionMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  mvIMPACT::acquire::TFlatFieldFilterCorrectionMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTFlatFieldFilterCorrectionMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFlatFieldFilterCorrectionMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTFlatFieldFilterCorrectionMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TFlatFieldFilterCorrectionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTFlatFieldFilterCorrectionMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFlatFieldFilterCorrectionMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFlatFieldFilterCorrectionMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTFlatFieldFilterCorrectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTFlatFieldFilterCorrectionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTFlatFieldFilterCorrectionMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTFlatFieldFilterCorrectionMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIFlatFieldFilterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIFlatFieldFilterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIFlatFieldFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIFlatFieldFilterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIFlatFieldFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIFlatFieldFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIFlatFieldFilterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIFlatFieldFilterMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIFlatFieldFilterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIFlatFieldFilterMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIFlatFieldFilterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIFlatFieldFilterMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TFlatFieldFilterMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TFlatFieldFilterMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFlatFieldFilterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TFlatFieldFilterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TFlatFieldFilterMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFlatFieldFilterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TFlatFieldFilterMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TFlatFieldFilterMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFlatFieldFilterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFlatFieldFilterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFlatFieldFilterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFlatFieldFilterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::read(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  mvIMPACT::acquire::TFlatFieldFilterMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TFlatFieldFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFlatFieldFilterMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  mvIMPACT::acquire::TFlatFieldFilterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TFlatFieldFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFlatFieldFilterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >* pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIFlatFieldFilterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TFlatFieldFilterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TFlatFieldFilterMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIFlatFieldFilterMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIFlatFieldFilterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIFlatFieldFilterMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIFlatFieldFilterMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIFlatFieldFilterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::write(mvIMPACT::acquire::TFlatFieldFilterMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::write(mvIMPACT::acquire::TFlatFieldFilterMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::write(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::write(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::write(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >::write(std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIFlatFieldFilterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIFlatFieldFilterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIFlatFieldFilterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIFlatFieldFilterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTFlatFieldFilterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *)new std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTFlatFieldFilterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TFlatFieldFilterMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTFlatFieldFilterMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTFlatFieldFilterMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TFlatFieldFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFlatFieldFilterMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *)new std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTFlatFieldFilterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTFlatFieldFilterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTFlatFieldFilterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *)new std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode >((std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTFlatFieldFilterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTFlatFieldFilterMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTFlatFieldFilterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTFlatFieldFilterMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTFlatFieldFilterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTFlatFieldFilterMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode >::pair(std::string,mvIMPACT::acquire::TFlatFieldFilterMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode >::pair(std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTFlatFieldFilterMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTFlatFieldFilterMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFlatFieldFilterMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTFlatFieldFilterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTFlatFieldFilterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTFlatFieldFilterMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFlatFieldFilterMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTFlatFieldFilterMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  mvIMPACT::acquire::TFlatFieldFilterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTFlatFieldFilterMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFlatFieldFilterMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTFlatFieldFilterMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TFlatFieldFilterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TFlatFieldFilterMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTFlatFieldFilterMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TFlatFieldFilterMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTFlatFieldFilterMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TFlatFieldFilterMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTFlatFieldFilterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTFlatFieldFilterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTFlatFieldFilterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTFlatFieldFilterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIHWUpdateResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIHWUpdateResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIHWUpdateResult" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIHWUpdateResult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIHWUpdateResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIHWUpdateResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIHWUpdateResult(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIHWUpdateResult", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIHWUpdateResult__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIHWUpdateResult__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIHWUpdateResult__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIHWUpdateResult'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIHWUpdateResult_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::THWUpdateResult> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::THWUpdateResult> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::THWUpdateResult> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::THWUpdateResult>* resultptr = new std::pair< std::string, mvIMPACT::acquire::THWUpdateResult>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIHWUpdateResult_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIHWUpdateResult_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIHWUpdateResult_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIHWUpdateResult_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::THWUpdateResult result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIHWUpdateResult_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::THWUpdateResult result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIHWUpdateResult_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIHWUpdateResult_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIHWUpdateResult_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIHWUpdateResult_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIHWUpdateResult_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::THWUpdateResult result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIHWUpdateResult_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::THWUpdateResult result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::THWUpdateResult result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::THWUpdateResult result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::THWUpdateResult result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIHWUpdateResult_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIHWUpdateResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIHWUpdateResult_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIHWUpdateResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIHWUpdateResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIHWUpdateResult_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIHWUpdateResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIHWUpdateResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIHWUpdateResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIHWUpdateResult_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIHWUpdateResult_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIHWUpdateResult_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIHWUpdateResult_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIHWUpdateResult_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::read(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::read(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::read(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::read(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::read(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::read(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  mvIMPACT::acquire::THWUpdateResult arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIHWUpdateResult_write" "', argument " "2"" of type '" "mvIMPACT::acquire::THWUpdateResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::THWUpdateResult >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIHWUpdateResult_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  mvIMPACT::acquire::THWUpdateResult arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIHWUpdateResult_write" "', argument " "2"" of type '" "mvIMPACT::acquire::THWUpdateResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::THWUpdateResult >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIHWUpdateResult_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIHWUpdateResult_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIHWUpdateResult_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIHWUpdateResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::THWUpdateResult >* pV = new std::vector<mvIMPACT::acquire::THWUpdateResult > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIHWUpdateResult_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::THWUpdateResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::THWUpdateResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIHWUpdateResult_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIHWUpdateResult_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIHWUpdateResult_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIHWUpdateResult_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIHWUpdateResult_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::write(mvIMPACT::acquire::THWUpdateResult,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::write(mvIMPACT::acquire::THWUpdateResult) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::write(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::write(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::write(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >::write(std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIHWUpdateResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIHWUpdateResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIHWUpdateResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIHWUpdateResult_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTHWUpdateResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *)new std::pair< std::string,mvIMPACT::acquire::THWUpdateResult >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTHWUpdateResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::THWUpdateResult arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTHWUpdateResult" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTHWUpdateResult" "', argument " "2"" of type '" "mvIMPACT::acquire::THWUpdateResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::THWUpdateResult >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *)new std::pair< std::string,mvIMPACT::acquire::THWUpdateResult >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTHWUpdateResult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *ptr = (std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTHWUpdateResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTHWUpdateResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *)new std::pair< std::string,mvIMPACT::acquire::THWUpdateResult >((std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTHWUpdateResult(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTHWUpdateResult", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTHWUpdateResult__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTHWUpdateResult__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTHWUpdateResult__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTHWUpdateResult'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::THWUpdateResult >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::THWUpdateResult >::pair(std::string,mvIMPACT::acquire::THWUpdateResult)\n"
  "    std::pair< std::string,mvIMPACT::acquire::THWUpdateResult >::pair(std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTHWUpdateResult_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTHWUpdateResult_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTHWUpdateResult_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTHWUpdateResult_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTHWUpdateResult_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTHWUpdateResult_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTHWUpdateResult_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTHWUpdateResult_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  mvIMPACT::acquire::THWUpdateResult arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTHWUpdateResult_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTHWUpdateResult_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTHWUpdateResult_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::THWUpdateResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::THWUpdateResult >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTHWUpdateResult_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::THWUpdateResult result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTHWUpdateResult_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::THWUpdateResult) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTHWUpdateResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTHWUpdateResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTHWUpdateResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTHWUpdateResult_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyII2COperationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyII2COperationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyII2COperationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyII2COperationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyII2COperationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyII2COperationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyII2COperationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyII2COperationMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyII2COperationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyII2COperationMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyII2COperationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyII2COperationMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyII2COperationMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TI2COperationMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TI2COperationMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TI2COperationMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TI2COperationMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TI2COperationMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyII2COperationMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyII2COperationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TI2COperationMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TI2COperationMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyII2COperationMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyII2COperationMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyII2COperationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyII2COperationMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyII2COperationMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TI2COperationMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TI2COperationMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TI2COperationMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TI2COperationMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TI2COperationMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyII2COperationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyII2COperationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyII2COperationMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyII2COperationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyII2COperationMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyII2COperationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyII2COperationMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyII2COperationMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyII2COperationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::read(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::read(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::read(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::read(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::read(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::read(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  mvIMPACT::acquire::TI2COperationMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TI2COperationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TI2COperationMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  mvIMPACT::acquire::TI2COperationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TI2COperationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TI2COperationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyII2COperationMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationMode >* pV = new std::vector<mvIMPACT::acquire::TI2COperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyII2COperationMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyII2COperationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyII2COperationMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyII2COperationMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyII2COperationMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyII2COperationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::write(mvIMPACT::acquire::TI2COperationMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::write(mvIMPACT::acquire::TI2COperationMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::write(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::write(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::write(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >::write(std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyII2COperationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyII2COperationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyII2COperationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyII2COperationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTI2COperationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *)new std::pair< std::string,mvIMPACT::acquire::TI2COperationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTI2COperationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TI2COperationMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTI2COperationMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTI2COperationMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TI2COperationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TI2COperationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *)new std::pair< std::string,mvIMPACT::acquire::TI2COperationMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTI2COperationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTI2COperationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTI2COperationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *)new std::pair< std::string,mvIMPACT::acquire::TI2COperationMode >((std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTI2COperationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTI2COperationMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTI2COperationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTI2COperationMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTI2COperationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTI2COperationMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TI2COperationMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TI2COperationMode >::pair(std::string,mvIMPACT::acquire::TI2COperationMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TI2COperationMode >::pair(std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTI2COperationMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTI2COperationMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTI2COperationMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTI2COperationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTI2COperationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTI2COperationMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTI2COperationMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTI2COperationMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  mvIMPACT::acquire::TI2COperationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTI2COperationMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTI2COperationMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTI2COperationMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TI2COperationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TI2COperationMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTI2COperationMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TI2COperationMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTI2COperationMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TI2COperationMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTI2COperationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTI2COperationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTI2COperationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTI2COperationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyII2COperationStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyII2COperationStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyII2COperationStatus" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyII2COperationStatus__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyII2COperationStatus" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyII2COperationStatus" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyII2COperationStatus(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyII2COperationStatus", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyII2COperationStatus__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyII2COperationStatus__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyII2COperationStatus__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyII2COperationStatus'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyII2COperationStatus_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TI2COperationStatus> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TI2COperationStatus> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TI2COperationStatus> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TI2COperationStatus>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TI2COperationStatus>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationStatus_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyII2COperationStatus_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyII2COperationStatus_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TI2COperationStatus result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationStatus_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TI2COperationStatus result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyII2COperationStatus_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyII2COperationStatus_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyII2COperationStatus_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyII2COperationStatus_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TI2COperationStatus result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationStatus_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TI2COperationStatus result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TI2COperationStatus result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TI2COperationStatus result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TI2COperationStatus result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationStatus_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyII2COperationStatus_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationStatus_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationStatus_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyII2COperationStatus_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyII2COperationStatus_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationStatus_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyII2COperationStatus_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationStatus_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyII2COperationStatus_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyII2COperationStatus_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyII2COperationStatus_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyII2COperationStatus_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyII2COperationStatus_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyII2COperationStatus_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::read(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::read(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::read(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::read(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::read(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::read(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  mvIMPACT::acquire::TI2COperationStatus arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationStatus_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TI2COperationStatus""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TI2COperationStatus >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationStatus_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  mvIMPACT::acquire::TI2COperationStatus arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyII2COperationStatus_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TI2COperationStatus""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TI2COperationStatus >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationStatus_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationStatus_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyII2COperationStatus_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyII2COperationStatus_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TI2COperationStatus >* pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyII2COperationStatus_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TI2COperationStatus >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TI2COperationStatus>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyII2COperationStatus_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyII2COperationStatus_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyII2COperationStatus_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyII2COperationStatus_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyII2COperationStatus_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyII2COperationStatus_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::write(mvIMPACT::acquire::TI2COperationStatus,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::write(mvIMPACT::acquire::TI2COperationStatus) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::write(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::write(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::write(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >::write(std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyII2COperationStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyII2COperationStatus" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyII2COperationStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyII2COperationStatus_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTI2COperationStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *)new std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTI2COperationStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TI2COperationStatus arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTI2COperationStatus" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTI2COperationStatus" "', argument " "2"" of type '" "mvIMPACT::acquire::TI2COperationStatus""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TI2COperationStatus >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *)new std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTI2COperationStatus__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *ptr = (std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTI2COperationStatus" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTI2COperationStatus" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *)new std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus >((std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTI2COperationStatus(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTI2COperationStatus", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTI2COperationStatus__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTI2COperationStatus__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTI2COperationStatus__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTI2COperationStatus'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus >::pair(std::string,mvIMPACT::acquire::TI2COperationStatus)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus >::pair(std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTI2COperationStatus_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTI2COperationStatus_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTI2COperationStatus_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTI2COperationStatus_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTI2COperationStatus_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTI2COperationStatus_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTI2COperationStatus_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTI2COperationStatus_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  mvIMPACT::acquire::TI2COperationStatus arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTI2COperationStatus_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTI2COperationStatus_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTI2COperationStatus_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TI2COperationStatus""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TI2COperationStatus >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTI2COperationStatus_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TI2COperationStatus result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTI2COperationStatus_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TI2COperationStatus) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTI2COperationStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTI2COperationStatus" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTI2COperationStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTI2COperationStatus_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIImageBufferPixelFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageBufferPixelFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIImageBufferPixelFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageBufferPixelFormat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIImageBufferPixelFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIImageBufferPixelFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageBufferPixelFormat(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIImageBufferPixelFormat", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIImageBufferPixelFormat__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIImageBufferPixelFormat__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIImageBufferPixelFormat__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIImageBufferPixelFormat'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageBufferPixelFormat_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TImageBufferPixelFormat> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TImageBufferPixelFormat> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TImageBufferPixelFormat> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TImageBufferPixelFormat>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TImageBufferPixelFormat>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageBufferPixelFormat_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageBufferPixelFormat_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageBufferPixelFormat result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageBufferPixelFormat result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageBufferPixelFormat_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageBufferPixelFormat_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageBufferPixelFormat_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageBufferPixelFormat_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageBufferPixelFormat result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageBufferPixelFormat result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageBufferPixelFormat result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageBufferPixelFormat result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageBufferPixelFormat result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferPixelFormat_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageBufferPixelFormat_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageBufferPixelFormat_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  mvIMPACT::acquire::TImageBufferPixelFormat arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageBufferPixelFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageBufferPixelFormat >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  mvIMPACT::acquire::TImageBufferPixelFormat arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageBufferPixelFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageBufferPixelFormat >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferPixelFormat_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferPixelFormat>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageBufferPixelFormat_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageBufferPixelFormat_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageBufferPixelFormat_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageBufferPixelFormat_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageBufferPixelFormat_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::write(mvIMPACT::acquire::TImageBufferPixelFormat,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::write(mvIMPACT::acquire::TImageBufferPixelFormat) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::write(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::write(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::write(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >::write(std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIImageBufferPixelFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIImageBufferPixelFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIImageBufferPixelFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIImageBufferPixelFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTImageBufferPixelFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *)new std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageBufferPixelFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TImageBufferPixelFormat arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTImageBufferPixelFormat" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTImageBufferPixelFormat" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageBufferPixelFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageBufferPixelFormat >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *)new std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageBufferPixelFormat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *ptr = (std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTImageBufferPixelFormat" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTImageBufferPixelFormat" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *)new std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat >((std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageBufferPixelFormat(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTImageBufferPixelFormat", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTImageBufferPixelFormat__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTImageBufferPixelFormat__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTImageBufferPixelFormat__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTImageBufferPixelFormat'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat >::pair(std::string,mvIMPACT::acquire::TImageBufferPixelFormat)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat >::pair(std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTImageBufferPixelFormat_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageBufferPixelFormat_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageBufferPixelFormat_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTImageBufferPixelFormat_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTImageBufferPixelFormat_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageBufferPixelFormat_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageBufferPixelFormat_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageBufferPixelFormat_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  mvIMPACT::acquire::TImageBufferPixelFormat arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageBufferPixelFormat_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageBufferPixelFormat_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTImageBufferPixelFormat_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageBufferPixelFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageBufferPixelFormat >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageBufferPixelFormat_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageBufferPixelFormat result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageBufferPixelFormat_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TImageBufferPixelFormat) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTImageBufferPixelFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTImageBufferPixelFormat" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTImageBufferPixelFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTImageBufferPixelFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIImageBufferFormatReinterpreterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageBufferFormatReinterpreterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIImageBufferFormatReinterpreterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageBufferFormatReinterpreterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIImageBufferFormatReinterpreterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIImageBufferFormatReinterpreterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &""'"); }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageBufferFormatReinterpreterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIImageBufferFormatReinterpreterMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIImageBufferFormatReinterpreterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIImageBufferFormatReinterpreterMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIImageBufferFormatReinterpreterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIImageBufferFormatReinterpreterMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageBufferFormatReinterpreterMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TImageBufferFormatReinterpreterMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageBufferFormatReinterpreterMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TImageBufferFormatReinterpreterMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageBufferFormatReinterpreterMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageBufferFormatReinterpreterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageBufferFormatReinterpreterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageBufferFormatReinterpreterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferFormatReinterpreterMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageBufferFormatReinterpreterMode_read", 0, 5, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageBufferFormatReinterpreterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::read(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::read(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::read(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::read(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::read(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::read(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  mvIMPACT::acquire::TImageBufferFormatReinterpreterMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageBufferFormatReinterpreterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  mvIMPACT::acquire::TImageBufferFormatReinterpreterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageBufferFormatReinterpreterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >(val2); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >* pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageBufferFormatReinterpreterMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageBufferFormatReinterpreterMode_write", 0, 4, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageBufferFormatReinterpreterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::write(mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::write(mvIMPACT::acquire::TImageBufferFormatReinterpreterMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::write(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::write(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::write(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::write(std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIImageBufferFormatReinterpreterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIImageBufferFormatReinterpreterMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIImageBufferFormatReinterpreterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIImageBufferFormatReinterpreterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTImageBufferFormatReinterpreterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *)new std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageBufferFormatReinterpreterMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TImageBufferFormatReinterpreterMode arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTImageBufferFormatReinterpreterMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTImageBufferFormatReinterpreterMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageBufferFormatReinterpreterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >(val2); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *)new std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageBufferFormatReinterpreterMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTImageBufferFormatReinterpreterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTImageBufferFormatReinterpreterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *)new std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >((std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageBufferFormatReinterpreterMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTImageBufferFormatReinterpreterMode", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTImageBufferFormatReinterpreterMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTImageBufferFormatReinterpreterMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTImageBufferFormatReinterpreterMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTImageBufferFormatReinterpreterMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::pair(std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >::pair(std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTImageBufferFormatReinterpreterMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageBufferFormatReinterpreterMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageBufferFormatReinterpreterMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTImageBufferFormatReinterpreterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTImageBufferFormatReinterpreterMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageBufferFormatReinterpreterMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageBufferFormatReinterpreterMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageBufferFormatReinterpreterMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  mvIMPACT::acquire::TImageBufferFormatReinterpreterMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageBufferFormatReinterpreterMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageBufferFormatReinterpreterMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTImageBufferFormatReinterpreterMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageBufferFormatReinterpreterMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageBufferFormatReinterpreterMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageBufferFormatReinterpreterMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageBufferFormatReinterpreterMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTImageBufferFormatReinterpreterMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTImageBufferFormatReinterpreterMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTImageBufferFormatReinterpreterMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTImageBufferFormatReinterpreterMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIImageDestinationPixelFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageDestinationPixelFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIImageDestinationPixelFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageDestinationPixelFormat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIImageDestinationPixelFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIImageDestinationPixelFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageDestinationPixelFormat(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIImageDestinationPixelFormat", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIImageDestinationPixelFormat__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIImageDestinationPixelFormat__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIImageDestinationPixelFormat__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIImageDestinationPixelFormat'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageDestinationPixelFormat_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TImageDestinationPixelFormat> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TImageDestinationPixelFormat> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TImageDestinationPixelFormat> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TImageDestinationPixelFormat>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TImageDestinationPixelFormat>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageDestinationPixelFormat_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageDestinationPixelFormat_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TImageDestinationPixelFormat result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageDestinationPixelFormat result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageDestinationPixelFormat_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageDestinationPixelFormat_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageDestinationPixelFormat_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageDestinationPixelFormat_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TImageDestinationPixelFormat result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageDestinationPixelFormat result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageDestinationPixelFormat result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageDestinationPixelFormat result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageDestinationPixelFormat result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageDestinationPixelFormat_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageDestinationPixelFormat_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageDestinationPixelFormat_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::read(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  mvIMPACT::acquire::TImageDestinationPixelFormat arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageDestinationPixelFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageDestinationPixelFormat >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  mvIMPACT::acquire::TImageDestinationPixelFormat arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageDestinationPixelFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageDestinationPixelFormat >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >* pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageDestinationPixelFormat_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageDestinationPixelFormat>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageDestinationPixelFormat_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageDestinationPixelFormat_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::write(mvIMPACT::acquire::TImageDestinationPixelFormat,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::write(mvIMPACT::acquire::TImageDestinationPixelFormat) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::write(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::write(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::write(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >::write(std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIImageDestinationPixelFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIImageDestinationPixelFormat" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIImageDestinationPixelFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIImageDestinationPixelFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTImageDestinationPixelFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *)new std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageDestinationPixelFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TImageDestinationPixelFormat arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTImageDestinationPixelFormat" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTImageDestinationPixelFormat" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageDestinationPixelFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageDestinationPixelFormat >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *)new std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageDestinationPixelFormat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *ptr = (std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTImageDestinationPixelFormat" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTImageDestinationPixelFormat" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *)new std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat >((std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageDestinationPixelFormat(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTImageDestinationPixelFormat", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTImageDestinationPixelFormat__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTImageDestinationPixelFormat__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTImageDestinationPixelFormat__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTImageDestinationPixelFormat'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat >::pair(std::string,mvIMPACT::acquire::TImageDestinationPixelFormat)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat >::pair(std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTImageDestinationPixelFormat_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageDestinationPixelFormat_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageDestinationPixelFormat_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTImageDestinationPixelFormat_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTImageDestinationPixelFormat_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageDestinationPixelFormat_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageDestinationPixelFormat_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageDestinationPixelFormat_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  mvIMPACT::acquire::TImageDestinationPixelFormat arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageDestinationPixelFormat_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageDestinationPixelFormat_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTImageDestinationPixelFormat_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageDestinationPixelFormat""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageDestinationPixelFormat >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageDestinationPixelFormat_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageDestinationPixelFormat result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageDestinationPixelFormat_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TImageDestinationPixelFormat) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTImageDestinationPixelFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTImageDestinationPixelFormat" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTImageDestinationPixelFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTImageDestinationPixelFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingFilter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIImageProcessingFilter" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingFilter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIImageProcessingFilter" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIImageProcessingFilter" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingFilter(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIImageProcessingFilter", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIImageProcessingFilter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIImageProcessingFilter__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIImageProcessingFilter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIImageProcessingFilter'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingFilter_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TImageProcessingFilter> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TImageProcessingFilter> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TImageProcessingFilter> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TImageProcessingFilter>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TImageProcessingFilter>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingFilter_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingFilter_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingFilter_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageProcessingFilter result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingFilter_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageProcessingFilter result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingFilter_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingFilter_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingFilter_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingFilter_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageProcessingFilter result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageProcessingFilter result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingFilter result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingFilter result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingFilter result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingFilter_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingFilter_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIImageProcessingFilter_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageProcessingFilter_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingFilter_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingFilter_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::read(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::read(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::read(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::read(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::read(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::read(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  mvIMPACT::acquire::TImageProcessingFilter arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingFilter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingFilter >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  mvIMPACT::acquire::TImageProcessingFilter arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingFilter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingFilter >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingFilter >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingFilter_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingFilter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingFilter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingFilter_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageProcessingFilter_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageProcessingFilter_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageProcessingFilter_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingFilter_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::write(mvIMPACT::acquire::TImageProcessingFilter,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::write(mvIMPACT::acquire::TImageProcessingFilter) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::write(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::write(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::write(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >::write(std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIImageProcessingFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIImageProcessingFilter" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIImageProcessingFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIImageProcessingFilter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingFilter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TImageProcessingFilter arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTImageProcessingFilter" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTImageProcessingFilter" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingFilter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingFilter >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingFilter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *ptr = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTImageProcessingFilter" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTImageProcessingFilter" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter >((std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingFilter(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTImageProcessingFilter", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTImageProcessingFilter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTImageProcessingFilter__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTImageProcessingFilter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTImageProcessingFilter'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter >::pair(std::string,mvIMPACT::acquire::TImageProcessingFilter)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter >::pair(std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingFilter_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageProcessingFilter_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingFilter_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTImageProcessingFilter_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTImageProcessingFilter_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingFilter_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingFilter_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingFilter_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  mvIMPACT::acquire::TImageProcessingFilter arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageProcessingFilter_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingFilter_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTImageProcessingFilter_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingFilter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingFilter >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingFilter_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingFilter result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingFilter_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TImageProcessingFilter) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTImageProcessingFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTImageProcessingFilter" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTImageProcessingFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTImageProcessingFilter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIImageProcessingMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIImageProcessingMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIImageProcessingMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIImageProcessingMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIImageProcessingMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIImageProcessingMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIImageProcessingMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIImageProcessingMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TImageProcessingMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TImageProcessingMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TImageProcessingMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TImageProcessingMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TImageProcessingMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageProcessingMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageProcessingMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageProcessingMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageProcessingMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIImageProcessingMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIImageProcessingMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageProcessingMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::read(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::read(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::read(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::read(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::read(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::read(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  mvIMPACT::acquire::TImageProcessingMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  mvIMPACT::acquire::TImageProcessingMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingMode >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageProcessingMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageProcessingMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageProcessingMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::write(mvIMPACT::acquire::TImageProcessingMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::write(mvIMPACT::acquire::TImageProcessingMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::write(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::write(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::write(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >::write(std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIImageProcessingMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIImageProcessingMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIImageProcessingMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIImageProcessingMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TImageProcessingMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTImageProcessingMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTImageProcessingMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTImageProcessingMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTImageProcessingMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode >((std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTImageProcessingMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTImageProcessingMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTImageProcessingMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTImageProcessingMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTImageProcessingMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode >::pair(std::string,mvIMPACT::acquire::TImageProcessingMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode >::pair(std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageProcessingMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTImageProcessingMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTImageProcessingMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  mvIMPACT::acquire::TImageProcessingMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageProcessingMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTImageProcessingMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TImageProcessingMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTImageProcessingMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTImageProcessingMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTImageProcessingMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTImageProcessingMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingOptimization__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingOptimization__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIImageProcessingOptimization" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingOptimization__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIImageProcessingOptimization" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIImageProcessingOptimization" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingOptimization(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIImageProcessingOptimization", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIImageProcessingOptimization__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIImageProcessingOptimization__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIImageProcessingOptimization__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIImageProcessingOptimization'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingOptimization_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TImageProcessingOptimization> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TImageProcessingOptimization> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TImageProcessingOptimization> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TImageProcessingOptimization>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TImageProcessingOptimization>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingOptimization_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingOptimization_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingOptimization_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TImageProcessingOptimization result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingOptimization_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageProcessingOptimization result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingOptimization_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingOptimization_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingOptimization_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingOptimization_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TImageProcessingOptimization result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageProcessingOptimization result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingOptimization result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingOptimization result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingOptimization result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingOptimization_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingOptimization_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageProcessingOptimization_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingOptimization_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingOptimization_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::read(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::read(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::read(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::read(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::read(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::read(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  mvIMPACT::acquire::TImageProcessingOptimization arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingOptimization""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingOptimization >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  mvIMPACT::acquire::TImageProcessingOptimization arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingOptimization""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingOptimization >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingOptimization_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingOptimization >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingOptimization>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingOptimization_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageProcessingOptimization_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageProcessingOptimization_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageProcessingOptimization_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingOptimization_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::write(mvIMPACT::acquire::TImageProcessingOptimization,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::write(mvIMPACT::acquire::TImageProcessingOptimization) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::write(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::write(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::write(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >::write(std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIImageProcessingOptimization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIImageProcessingOptimization" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIImageProcessingOptimization_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIImageProcessingOptimization_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingOptimization__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingOptimization__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TImageProcessingOptimization arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTImageProcessingOptimization" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTImageProcessingOptimization" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingOptimization""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingOptimization >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingOptimization__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *ptr = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTImageProcessingOptimization" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTImageProcessingOptimization" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization >((std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingOptimization(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTImageProcessingOptimization", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTImageProcessingOptimization__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTImageProcessingOptimization__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTImageProcessingOptimization__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTImageProcessingOptimization'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization >::pair(std::string,mvIMPACT::acquire::TImageProcessingOptimization)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization >::pair(std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingOptimization_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageProcessingOptimization_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingOptimization_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTImageProcessingOptimization_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTImageProcessingOptimization_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingOptimization_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingOptimization_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingOptimization_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  mvIMPACT::acquire::TImageProcessingOptimization arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageProcessingOptimization_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingOptimization_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTImageProcessingOptimization_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingOptimization""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingOptimization >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingOptimization_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingOptimization result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingOptimization_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TImageProcessingOptimization) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTImageProcessingOptimization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTImageProcessingOptimization" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTImageProcessingOptimization_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTImageProcessingOptimization_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIImageProcessingResult" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingResult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIImageProcessingResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIImageProcessingResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageProcessingResult(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIImageProcessingResult", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIImageProcessingResult__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIImageProcessingResult__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIImageProcessingResult__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIImageProcessingResult'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingResult_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TImageProcessingResult> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TImageProcessingResult> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TImageProcessingResult> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TImageProcessingResult>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TImageProcessingResult>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingResult_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingResult_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingResult_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageProcessingResult result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingResult_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageProcessingResult result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingResult_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingResult_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingResult_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingResult_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageProcessingResult result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingResult_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageProcessingResult result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingResult result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingResult result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingResult result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingResult_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingResult_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIImageProcessingResult_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingResult_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIImageProcessingResult_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageProcessingResult_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingResult_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingResult_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::read(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::read(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::read(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::read(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::read(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::read(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  mvIMPACT::acquire::TImageProcessingResult arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingResult_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingResult >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingResult_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  mvIMPACT::acquire::TImageProcessingResult arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageProcessingResult_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingResult >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingResult_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingResult_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageProcessingResult_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageProcessingResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageProcessingResult >* pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageProcessingResult_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageProcessingResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageProcessingResult>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageProcessingResult_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageProcessingResult_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageProcessingResult_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageProcessingResult_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageProcessingResult_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::write(mvIMPACT::acquire::TImageProcessingResult,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::write(mvIMPACT::acquire::TImageProcessingResult) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::write(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::write(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::write(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >::write(std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIImageProcessingResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIImageProcessingResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIImageProcessingResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIImageProcessingResult_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TImageProcessingResult arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTImageProcessingResult" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTImageProcessingResult" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingResult >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingResult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *ptr = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTImageProcessingResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTImageProcessingResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *)new std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult >((std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageProcessingResult(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTImageProcessingResult", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTImageProcessingResult__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTImageProcessingResult__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTImageProcessingResult__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTImageProcessingResult'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult >::pair(std::string,mvIMPACT::acquire::TImageProcessingResult)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult >::pair(std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingResult_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageProcessingResult_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingResult_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTImageProcessingResult_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTImageProcessingResult_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingResult_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingResult_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingResult_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  mvIMPACT::acquire::TImageProcessingResult arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageProcessingResult_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingResult_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTImageProcessingResult_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageProcessingResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageProcessingResult >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageProcessingResult_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageProcessingResult result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageProcessingResult_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TImageProcessingResult) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTImageProcessingResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTImageProcessingResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTImageProcessingResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTImageProcessingResult_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIRequestImageMemoryMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRequestImageMemoryMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIRequestImageMemoryMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRequestImageMemoryMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIRequestImageMemoryMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIRequestImageMemoryMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRequestImageMemoryMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIRequestImageMemoryMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIRequestImageMemoryMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIRequestImageMemoryMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIRequestImageMemoryMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIRequestImageMemoryMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRequestImageMemoryMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TRequestImageMemoryMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TRequestImageMemoryMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TRequestImageMemoryMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TRequestImageMemoryMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TRequestImageMemoryMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestImageMemoryMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestImageMemoryMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRequestImageMemoryMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRequestImageMemoryMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestImageMemoryMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestImageMemoryMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRequestImageMemoryMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRequestImageMemoryMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRequestImageMemoryMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRequestImageMemoryMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestImageMemoryMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestImageMemoryMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestImageMemoryMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestImageMemoryMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestImageMemoryMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestImageMemoryMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::read(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::read(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::read(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::read(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::read(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::read(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  mvIMPACT::acquire::TRequestImageMemoryMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestImageMemoryMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestImageMemoryMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  mvIMPACT::acquire::TRequestImageMemoryMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestImageMemoryMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestImageMemoryMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestImageMemoryMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestImageMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestImageMemoryMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestImageMemoryMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRequestImageMemoryMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRequestImageMemoryMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRequestImageMemoryMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestImageMemoryMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::write(mvIMPACT::acquire::TRequestImageMemoryMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::write(mvIMPACT::acquire::TRequestImageMemoryMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::write(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::write(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::write(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >::write(std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIRequestImageMemoryMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIRequestImageMemoryMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIRequestImageMemoryMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIRequestImageMemoryMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTRequestImageMemoryMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *)new std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRequestImageMemoryMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TRequestImageMemoryMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTRequestImageMemoryMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTRequestImageMemoryMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestImageMemoryMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestImageMemoryMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *)new std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRequestImageMemoryMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTRequestImageMemoryMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTRequestImageMemoryMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *)new std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode >((std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRequestImageMemoryMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTRequestImageMemoryMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTRequestImageMemoryMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTRequestImageMemoryMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTRequestImageMemoryMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTRequestImageMemoryMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode >::pair(std::string,mvIMPACT::acquire::TRequestImageMemoryMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode >::pair(std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTRequestImageMemoryMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRequestImageMemoryMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestImageMemoryMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTRequestImageMemoryMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTRequestImageMemoryMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRequestImageMemoryMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestImageMemoryMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRequestImageMemoryMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  mvIMPACT::acquire::TRequestImageMemoryMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRequestImageMemoryMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestImageMemoryMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTRequestImageMemoryMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestImageMemoryMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestImageMemoryMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRequestImageMemoryMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestImageMemoryMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestImageMemoryMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TRequestImageMemoryMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTRequestImageMemoryMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTRequestImageMemoryMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTRequestImageMemoryMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTRequestImageMemoryMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIImageRequestControlMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageRequestControlMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIImageRequestControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageRequestControlMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIImageRequestControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIImageRequestControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIImageRequestControlMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIImageRequestControlMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIImageRequestControlMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIImageRequestControlMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIImageRequestControlMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIImageRequestControlMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageRequestControlMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TImageRequestControlMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TImageRequestControlMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TImageRequestControlMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TImageRequestControlMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TImageRequestControlMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageRequestControlMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageRequestControlMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageRequestControlMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageRequestControlMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageRequestControlMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageRequestControlMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageRequestControlMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageRequestControlMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageRequestControlMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIImageRequestControlMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TImageRequestControlMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TImageRequestControlMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageRequestControlMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageRequestControlMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageRequestControlMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageRequestControlMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageRequestControlMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIImageRequestControlMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageRequestControlMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageRequestControlMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageRequestControlMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::read(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::read(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::read(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::read(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::read(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::read(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  mvIMPACT::acquire::TImageRequestControlMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageRequestControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageRequestControlMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  mvIMPACT::acquire::TImageRequestControlMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageRequestControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageRequestControlMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TImageRequestControlMode >* pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIImageRequestControlMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TImageRequestControlMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TImageRequestControlMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIImageRequestControlMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageRequestControlMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageRequestControlMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIImageRequestControlMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIImageRequestControlMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::write(mvIMPACT::acquire::TImageRequestControlMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::write(mvIMPACT::acquire::TImageRequestControlMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::write(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::write(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::write(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >::write(std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIImageRequestControlMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIImageRequestControlMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIImageRequestControlMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIImageRequestControlMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTImageRequestControlMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *)new std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageRequestControlMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TImageRequestControlMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  { std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTImageRequestControlMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTImageRequestControlMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageRequestControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageRequestControlMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *)new std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageRequestControlMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTImageRequestControlMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTImageRequestControlMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *)new std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode >((std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTImageRequestControlMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTImageRequestControlMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTImageRequestControlMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTImageRequestControlMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTImageRequestControlMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTImageRequestControlMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode >::pair(std::string,mvIMPACT::acquire::TImageRequestControlMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode >::pair(std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTImageRequestControlMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageRequestControlMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageRequestControlMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTImageRequestControlMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTImageRequestControlMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageRequestControlMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageRequestControlMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageRequestControlMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  mvIMPACT::acquire::TImageRequestControlMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTImageRequestControlMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageRequestControlMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTImageRequestControlMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TImageRequestControlMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TImageRequestControlMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTImageRequestControlMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TImageRequestControlMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTImageRequestControlMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TImageRequestControlMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTImageRequestControlMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTImageRequestControlMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTImageRequestControlMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTImageRequestControlMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIInfoSensorColorMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInfoSensorColorMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIInfoSensorColorMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInfoSensorColorMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIInfoSensorColorMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIInfoSensorColorMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInfoSensorColorMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIInfoSensorColorMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIInfoSensorColorMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIInfoSensorColorMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIInfoSensorColorMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIInfoSensorColorMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorColorMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TInfoSensorColorMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TInfoSensorColorMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TInfoSensorColorMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TInfoSensorColorMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TInfoSensorColorMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorColorMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorColorMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInfoSensorColorMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TInfoSensorColorMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorColorMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TInfoSensorColorMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorColorMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInfoSensorColorMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorColorMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorColorMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TInfoSensorColorMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TInfoSensorColorMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInfoSensorColorMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInfoSensorColorMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInfoSensorColorMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorColorMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorColorMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInfoSensorColorMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::read(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::read(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::read(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::read(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::read(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::read(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  mvIMPACT::acquire::TInfoSensorColorMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TInfoSensorColorMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInfoSensorColorMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  mvIMPACT::acquire::TInfoSensorColorMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TInfoSensorColorMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInfoSensorColorMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorColorMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorColorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorColorMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorColorMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIInfoSensorColorMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIInfoSensorColorMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIInfoSensorColorMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInfoSensorColorMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::write(mvIMPACT::acquire::TInfoSensorColorMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::write(mvIMPACT::acquire::TInfoSensorColorMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::write(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::write(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::write(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >::write(std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIInfoSensorColorMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIInfoSensorColorMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIInfoSensorColorMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIInfoSensorColorMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTInfoSensorColorMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *)new std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInfoSensorColorMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TInfoSensorColorMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTInfoSensorColorMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTInfoSensorColorMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TInfoSensorColorMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInfoSensorColorMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *)new std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInfoSensorColorMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTInfoSensorColorMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTInfoSensorColorMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *)new std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode >((std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInfoSensorColorMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTInfoSensorColorMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTInfoSensorColorMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTInfoSensorColorMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTInfoSensorColorMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTInfoSensorColorMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode >::pair(std::string,mvIMPACT::acquire::TInfoSensorColorMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode >::pair(std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTInfoSensorColorMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTInfoSensorColorMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInfoSensorColorMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTInfoSensorColorMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTInfoSensorColorMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInfoSensorColorMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInfoSensorColorMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInfoSensorColorMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  mvIMPACT::acquire::TInfoSensorColorMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTInfoSensorColorMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInfoSensorColorMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTInfoSensorColorMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TInfoSensorColorMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInfoSensorColorMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInfoSensorColorMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInfoSensorColorMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInfoSensorColorMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TInfoSensorColorMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTInfoSensorColorMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTInfoSensorColorMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTInfoSensorColorMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTInfoSensorColorMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIInfoSensorType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInfoSensorType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIInfoSensorType" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInfoSensorType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIInfoSensorType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIInfoSensorType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInfoSensorType(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIInfoSensorType", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIInfoSensorType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIInfoSensorType__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIInfoSensorType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIInfoSensorType'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorType_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TInfoSensorType> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TInfoSensorType> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TInfoSensorType> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TInfoSensorType>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TInfoSensorType>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorType_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorType_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIInfoSensorType_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInfoSensorType_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInfoSensorType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TInfoSensorType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorType_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TInfoSensorType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorType_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIInfoSensorType_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInfoSensorType_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInfoSensorType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorType_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorType_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TInfoSensorType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorType_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TInfoSensorType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInfoSensorType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInfoSensorType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInfoSensorType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInfoSensorType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInfoSensorType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIInfoSensorType_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInfoSensorType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorType_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIInfoSensorType_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIInfoSensorType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInfoSensorType_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInfoSensorType_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIInfoSensorType_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIInfoSensorType_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIInfoSensorType_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIInfoSensorType_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInfoSensorType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::read(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::read(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::read(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::read(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::read(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::read(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  mvIMPACT::acquire::TInfoSensorType arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TInfoSensorType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInfoSensorType >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  mvIMPACT::acquire::TInfoSensorType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInfoSensorType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TInfoSensorType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInfoSensorType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInfoSensorType_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInfoSensorType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInfoSensorType >* pV = new std::vector<mvIMPACT::acquire::TInfoSensorType > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInfoSensorType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInfoSensorType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInfoSensorType>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInfoSensorType_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIInfoSensorType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInfoSensorType_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIInfoSensorType_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIInfoSensorType_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIInfoSensorType_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIInfoSensorType_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInfoSensorType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::write(mvIMPACT::acquire::TInfoSensorType,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::write(mvIMPACT::acquire::TInfoSensorType) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::write(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::write(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::write(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >::write(std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIInfoSensorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIInfoSensorType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIInfoSensorType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIInfoSensorType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTInfoSensorType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *)new std::pair< std::string,mvIMPACT::acquire::TInfoSensorType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInfoSensorType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TInfoSensorType arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTInfoSensorType" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTInfoSensorType" "', argument " "2"" of type '" "mvIMPACT::acquire::TInfoSensorType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInfoSensorType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *)new std::pair< std::string,mvIMPACT::acquire::TInfoSensorType >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInfoSensorType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *ptr = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTInfoSensorType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTInfoSensorType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *)new std::pair< std::string,mvIMPACT::acquire::TInfoSensorType >((std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInfoSensorType(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTInfoSensorType", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTInfoSensorType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTInfoSensorType__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTInfoSensorType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTInfoSensorType'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TInfoSensorType >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TInfoSensorType >::pair(std::string,mvIMPACT::acquire::TInfoSensorType)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TInfoSensorType >::pair(std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTInfoSensorType_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTInfoSensorType_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInfoSensorType_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTInfoSensorType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTInfoSensorType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInfoSensorType_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInfoSensorType_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInfoSensorType_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  mvIMPACT::acquire::TInfoSensorType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTInfoSensorType_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInfoSensorType_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTInfoSensorType_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TInfoSensorType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInfoSensorType >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInfoSensorType_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInfoSensorType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInfoSensorType_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TInfoSensorType) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTInfoSensorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTInfoSensorType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTInfoSensorType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTInfoSensorType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIInterfaceEnumerationBehaviour__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInterfaceEnumerationBehaviour__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIInterfaceEnumerationBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInterfaceEnumerationBehaviour__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIInterfaceEnumerationBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIInterfaceEnumerationBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInterfaceEnumerationBehaviour(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIInterfaceEnumerationBehaviour", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIInterfaceEnumerationBehaviour__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIInterfaceEnumerationBehaviour__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIInterfaceEnumerationBehaviour__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIInterfaceEnumerationBehaviour'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInterfaceEnumerationBehaviour_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TInterfaceEnumerationBehaviour> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TInterfaceEnumerationBehaviour> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TInterfaceEnumerationBehaviour> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TInterfaceEnumerationBehaviour>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TInterfaceEnumerationBehaviour>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterfaceEnumerationBehaviour_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInterfaceEnumerationBehaviour_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInterfaceEnumerationBehaviour_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TInterfaceEnumerationBehaviour result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterfaceEnumerationBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TInterfaceEnumerationBehaviour result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterfaceEnumerationBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInterfaceEnumerationBehaviour_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInterfaceEnumerationBehaviour_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TInterfaceEnumerationBehaviour result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterfaceEnumerationBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TInterfaceEnumerationBehaviour result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterfaceEnumerationBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInterfaceEnumerationBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterfaceEnumerationBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInterfaceEnumerationBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterfaceEnumerationBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInterfaceEnumerationBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterfaceEnumerationBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterfaceEnumerationBehaviour_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInterfaceEnumerationBehaviour_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInterfaceEnumerationBehaviour_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::read(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::read(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::read(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::read(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::read(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::read(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  mvIMPACT::acquire::TInterfaceEnumerationBehaviour arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TInterfaceEnumerationBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  mvIMPACT::acquire::TInterfaceEnumerationBehaviour arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TInterfaceEnumerationBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >* pV = new std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterfaceEnumerationBehaviour_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterfaceEnumerationBehaviour>( *i ) ) ) {
        SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterfaceEnumerationBehaviour_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInterfaceEnumerationBehaviour_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIInterfaceEnumerationBehaviour_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInterfaceEnumerationBehaviour_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::write(mvIMPACT::acquire::TInterfaceEnumerationBehaviour,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::write(mvIMPACT::acquire::TInterfaceEnumerationBehaviour) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::write(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::write(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::write(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::write(std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIInterfaceEnumerationBehaviour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIInterfaceEnumerationBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIInterfaceEnumerationBehaviour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIInterfaceEnumerationBehaviour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTInterfaceEnumerationBehaviour__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *)new std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInterfaceEnumerationBehaviour__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TInterfaceEnumerationBehaviour arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTInterfaceEnumerationBehaviour" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTInterfaceEnumerationBehaviour" "', argument " "2"" of type '" "mvIMPACT::acquire::TInterfaceEnumerationBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *)new std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInterfaceEnumerationBehaviour__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *ptr = (std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTInterfaceEnumerationBehaviour" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTInterfaceEnumerationBehaviour" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *)new std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour >((std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInterfaceEnumerationBehaviour(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTInterfaceEnumerationBehaviour", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTInterfaceEnumerationBehaviour__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTInterfaceEnumerationBehaviour__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTInterfaceEnumerationBehaviour__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTInterfaceEnumerationBehaviour'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::pair(std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour >::pair(std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTInterfaceEnumerationBehaviour_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTInterfaceEnumerationBehaviour_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInterfaceEnumerationBehaviour_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTInterfaceEnumerationBehaviour_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTInterfaceEnumerationBehaviour_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInterfaceEnumerationBehaviour_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInterfaceEnumerationBehaviour_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInterfaceEnumerationBehaviour_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  mvIMPACT::acquire::TInterfaceEnumerationBehaviour arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTInterfaceEnumerationBehaviour_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInterfaceEnumerationBehaviour_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTInterfaceEnumerationBehaviour_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TInterfaceEnumerationBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInterfaceEnumerationBehaviour_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInterfaceEnumerationBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInterfaceEnumerationBehaviour_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TInterfaceEnumerationBehaviour) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTInterfaceEnumerationBehaviour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTInterfaceEnumerationBehaviour" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTInterfaceEnumerationBehaviour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTInterfaceEnumerationBehaviour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIInterlacedMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInterlacedMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIInterlacedMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInterlacedMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIInterlacedMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIInterlacedMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIInterlacedMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIInterlacedMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIInterlacedMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIInterlacedMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIInterlacedMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIInterlacedMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInterlacedMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TInterlacedMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TInterlacedMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TInterlacedMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TInterlacedMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TInterlacedMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterlacedMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInterlacedMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) { PyObject *retobj = _wrap_PropertyIInterlacedMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInterlacedMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInterlacedMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TInterlacedMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterlacedMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TInterlacedMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInterlacedMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIInterlacedMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInterlacedMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInterlacedMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInterlacedMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIInterlacedMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TInterlacedMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterlacedMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TInterlacedMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInterlacedMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInterlacedMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInterlacedMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterlacedMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInterlacedMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterlacedMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterlacedMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInterlacedMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIInterlacedMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterlacedMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInterlacedMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterlacedMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInterlacedMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIInterlacedMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIInterlacedMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInterlacedMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInterlacedMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIInterlacedMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIInterlacedMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIInterlacedMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIInterlacedMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInterlacedMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::read(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::read(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::read(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::read(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::read(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::read(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  mvIMPACT::acquire::TInterlacedMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterlacedMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TInterlacedMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInterlacedMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterlacedMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  mvIMPACT::acquire::TInterlacedMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIInterlacedMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TInterlacedMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInterlacedMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterlacedMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterlacedMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIInterlacedMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIInterlacedMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TInterlacedMode >* pV = new std::vector<mvIMPACT::acquire::TInterlacedMode > (0); arg2 = pV; }
   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIInterlacedMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TInterlacedMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TInterlacedMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIInterlacedMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIInterlacedMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIInterlacedMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIInterlacedMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIInterlacedMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIInterlacedMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIInterlacedMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIInterlacedMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::write(mvIMPACT::acquire::TInterlacedMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::write(mvIMPACT::acquire::TInterlacedMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::write(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::write(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::write(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >::write(std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIInterlacedMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIInterlacedMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIInterlacedMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIInterlacedMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTInterlacedMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *)new std::pair< std::string,mvIMPACT::acquire::TInterlacedMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInterlacedMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TInterlacedMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTInterlacedMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTInterlacedMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TInterlacedMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInterlacedMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *)new std::pair< std::string,mvIMPACT::acquire::TInterlacedMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInterlacedMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTInterlacedMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTInterlacedMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *)new std::pair< std::string,mvIMPACT::acquire::TInterlacedMode >((std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTInterlacedMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTInterlacedMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTInterlacedMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTInterlacedMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTInterlacedMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTInterlacedMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TInterlacedMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TInterlacedMode >::pair(std::string,mvIMPACT::acquire::TInterlacedMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TInterlacedMode >::pair(std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTInterlacedMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTInterlacedMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInterlacedMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTInterlacedMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTInterlacedMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInterlacedMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInterlacedMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInterlacedMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  mvIMPACT::acquire::TInterlacedMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTInterlacedMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInterlacedMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTInterlacedMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TInterlacedMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TInterlacedMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTInterlacedMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TInterlacedMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTInterlacedMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TInterlacedMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTInterlacedMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTInterlacedMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTInterlacedMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTInterlacedMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyILineCounter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILineCounter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyILineCounter" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILineCounter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyILineCounter" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyILineCounter" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILineCounter(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyILineCounter", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyILineCounter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyILineCounter__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyILineCounter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyILineCounter'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TLineCounter >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLineCounter > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILineCounter_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TLineCounter> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TLineCounter> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TLineCounter> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TLineCounter>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TLineCounter>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILineCounter_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILineCounter_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILineCounter_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILineCounter_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILineCounter_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLineCounter result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILineCounter_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLineCounter result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILineCounter_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILineCounter_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILineCounter_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILineCounter_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILineCounter_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILineCounter_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLineCounter result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILineCounter_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLineCounter result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLineCounter result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLineCounter result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLineCounter result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILineCounter_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILineCounter_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILineCounter_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILineCounter_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILineCounter_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyILineCounter_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILineCounter_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILineCounter_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILineCounter_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILineCounter_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyILineCounter_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyILineCounter_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILineCounter_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILineCounter_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILineCounter_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyILineCounter_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILineCounter_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyILineCounter_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILineCounter_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::read(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::read(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::read(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::read(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::read(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::read(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  mvIMPACT::acquire::TLineCounter arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILineCounter_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLineCounter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLineCounter >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILineCounter_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  mvIMPACT::acquire::TLineCounter arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILineCounter_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLineCounter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLineCounter >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILineCounter_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILineCounter_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILineCounter_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILineCounter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLineCounter >* pV = new std::vector<mvIMPACT::acquire::TLineCounter > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILineCounter_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLineCounter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLineCounter>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILineCounter_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyILineCounter_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILineCounter_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyILineCounter_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyILineCounter_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILineCounter_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILineCounter_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILineCounter_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::write(mvIMPACT::acquire::TLineCounter,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::write(mvIMPACT::acquire::TLineCounter) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::write(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::write(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::write(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >::write(std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyILineCounter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyILineCounter" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyILineCounter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyILineCounter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTLineCounter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLineCounter > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLineCounter > *)new std::pair< std::string,mvIMPACT::acquire::TLineCounter >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLineCounter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TLineCounter arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TLineCounter > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTLineCounter" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTLineCounter" "', argument " "2"" of type '" "mvIMPACT::acquire::TLineCounter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLineCounter >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLineCounter > *)new std::pair< std::string,mvIMPACT::acquire::TLineCounter >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLineCounter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLineCounter > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TLineCounter > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TLineCounter > *ptr = (std::pair< std::string,mvIMPACT::acquire::TLineCounter > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTLineCounter" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLineCounter > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTLineCounter" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLineCounter > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLineCounter > *)new std::pair< std::string,mvIMPACT::acquire::TLineCounter >((std::pair< std::string,mvIMPACT::acquire::TLineCounter > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLineCounter(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTLineCounter", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTLineCounter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTLineCounter__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTLineCounter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTLineCounter'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TLineCounter >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLineCounter >::pair(std::string,mvIMPACT::acquire::TLineCounter)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLineCounter >::pair(std::pair< std::string,mvIMPACT::acquire::TLineCounter > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTLineCounter_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLineCounter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLineCounter > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLineCounter_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLineCounter_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLineCounter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLineCounter > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTLineCounter_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTLineCounter_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLineCounter_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLineCounter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLineCounter_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLineCounter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLineCounter > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLineCounter_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLineCounter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLineCounter > *) 0 ;
  mvIMPACT::acquire::TLineCounter arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLineCounter_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLineCounter_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLineCounter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLineCounter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTLineCounter_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TLineCounter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLineCounter >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLineCounter_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLineCounter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLineCounter result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLineCounter_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLineCounter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLineCounter > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TLineCounter) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTLineCounter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLineCounter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLineCounter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTLineCounter" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLineCounter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLineCounter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTLineCounter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTLineCounter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyILUTGammaMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTGammaMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyILUTGammaMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTGammaMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyILUTGammaMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyILUTGammaMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTGammaMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyILUTGammaMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyILUTGammaMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyILUTGammaMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyILUTGammaMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyILUTGammaMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTGammaMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TLUTGammaMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTGammaMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTGammaMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TLUTGammaMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TLUTGammaMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTGammaMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTGammaMode_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILUTGammaMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTGammaMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTGammaMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTGammaMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTGammaMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTGammaMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILUTGammaMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTGammaMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTGammaMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTGammaMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTGammaMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTGammaMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTGammaMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTGammaMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTGammaMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTGammaMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTGammaMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTGammaMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTGammaMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTGammaMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTGammaMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyILUTGammaMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTGammaMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTGammaMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTGammaMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTGammaMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyILUTGammaMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTGammaMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyILUTGammaMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTGammaMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::read(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::read(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::read(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::read(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::read(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::read(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  mvIMPACT::acquire::TLUTGammaMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTGammaMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTGammaMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTGammaMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTGammaMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  mvIMPACT::acquire::TLUTGammaMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTGammaMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTGammaMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTGammaMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTGammaMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTGammaMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTGammaMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTGammaMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTGammaMode >* pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTGammaMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTGammaMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTGammaMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTGammaMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTGammaMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyILUTGammaMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyILUTGammaMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTGammaMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTGammaMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::write(mvIMPACT::acquire::TLUTGammaMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::write(mvIMPACT::acquire::TLUTGammaMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::write(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::write(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::write(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >::write(std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyILUTGammaMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyILUTGammaMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyILUTGammaMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyILUTGammaMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTLUTGammaMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *)new std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTGammaMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TLUTGammaMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTLUTGammaMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTLUTGammaMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTGammaMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTGammaMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *)new std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTGammaMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTLUTGammaMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTLUTGammaMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *)new std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode >((std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTGammaMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTLUTGammaMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTLUTGammaMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTLUTGammaMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTLUTGammaMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTLUTGammaMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode >::pair(std::string,mvIMPACT::acquire::TLUTGammaMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode >::pair(std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTLUTGammaMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTGammaMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTGammaMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTLUTGammaMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTLUTGammaMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTGammaMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTGammaMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTGammaMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  mvIMPACT::acquire::TLUTGammaMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTGammaMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTGammaMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTLUTGammaMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTGammaMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTGammaMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTGammaMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTGammaMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTGammaMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TLUTGammaMode) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTLUTGammaMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTLUTGammaMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTLUTGammaMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTLUTGammaMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyILUTImplementation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTImplementation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyILUTImplementation" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTImplementation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyILUTImplementation" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyILUTImplementation" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTImplementation(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyILUTImplementation", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyILUTImplementation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyILUTImplementation__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyILUTImplementation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyILUTImplementation'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTImplementation_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TLUTImplementation> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTImplementation> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTImplementation> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TLUTImplementation>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TLUTImplementation>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTImplementation_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTImplementation_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTImplementation_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTImplementation result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTImplementation_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTImplementation result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTImplementation_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTImplementation_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTImplementation_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTImplementation_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTImplementation result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTImplementation_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTImplementation result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTImplementation result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTImplementation result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTImplementation result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTImplementation_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTImplementation_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTImplementation_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTImplementation_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTImplementation_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyILUTImplementation_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTImplementation_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTImplementation_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTImplementation_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTImplementation_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILUTImplementation_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyILUTImplementation_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTImplementation_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyILUTImplementation_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTImplementation_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::read(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::read(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::read(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::read(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::read(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::read(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  mvIMPACT::acquire::TLUTImplementation arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTImplementation_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTImplementation""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTImplementation >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTImplementation_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  mvIMPACT::acquire::TLUTImplementation arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTImplementation_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTImplementation""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTImplementation >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTImplementation_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTImplementation_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTImplementation_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTImplementation_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTImplementation >* pV = new std::vector<mvIMPACT::acquire::TLUTImplementation > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTImplementation_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTImplementation >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTImplementation>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTImplementation_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTImplementation_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyILUTImplementation_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyILUTImplementation_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTImplementation_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTImplementation_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::write(mvIMPACT::acquire::TLUTImplementation,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::write(mvIMPACT::acquire::TLUTImplementation) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::write(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::write(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::write(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >::write(std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyILUTImplementation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyILUTImplementation" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyILUTImplementation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyILUTImplementation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTLUTImplementation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *)new std::pair< std::string,mvIMPACT::acquire::TLUTImplementation >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTImplementation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TLUTImplementation arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTLUTImplementation" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTLUTImplementation" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTImplementation""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTImplementation >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *)new std::pair< std::string,mvIMPACT::acquire::TLUTImplementation >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTImplementation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *ptr = (std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTLUTImplementation" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTLUTImplementation" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *)new std::pair< std::string,mvIMPACT::acquire::TLUTImplementation >((std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTImplementation(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTLUTImplementation", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTLUTImplementation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTLUTImplementation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTLUTImplementation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTLUTImplementation'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TLUTImplementation >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTImplementation >::pair(std::string,mvIMPACT::acquire::TLUTImplementation)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTImplementation >::pair(std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTLUTImplementation_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTImplementation_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTImplementation_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTLUTImplementation_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTLUTImplementation_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTImplementation_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTImplementation_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTImplementation_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  mvIMPACT::acquire::TLUTImplementation arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTImplementation_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTImplementation_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTLUTImplementation_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTImplementation""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTImplementation >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTImplementation_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTImplementation result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTImplementation_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TLUTImplementation) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTLUTImplementation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTLUTImplementation" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTLUTImplementation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTLUTImplementation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyILUTInterpolationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTInterpolationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyILUTInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTInterpolationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyILUTInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyILUTInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTInterpolationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyILUTInterpolationMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyILUTInterpolationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyILUTInterpolationMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyILUTInterpolationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyILUTInterpolationMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTInterpolationMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TLUTInterpolationMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTInterpolationMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTInterpolationMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TLUTInterpolationMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TLUTInterpolationMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTInterpolationMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTInterpolationMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTInterpolationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTInterpolationMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTInterpolationMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTInterpolationMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTInterpolationMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTInterpolationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTInterpolationMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTInterpolationMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTInterpolationMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTInterpolationMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTInterpolationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTInterpolationMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILUTInterpolationMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTInterpolationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::read(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::read(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::read(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::read(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::read(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::read(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  mvIMPACT::acquire::TLUTInterpolationMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTInterpolationMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  mvIMPACT::acquire::TLUTInterpolationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTInterpolationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTInterpolationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTInterpolationMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTInterpolationMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTInterpolationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyILUTInterpolationMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTInterpolationMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTInterpolationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::write(mvIMPACT::acquire::TLUTInterpolationMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::write(mvIMPACT::acquire::TLUTInterpolationMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::write(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::write(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::write(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >::write(std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyILUTInterpolationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyILUTInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyILUTInterpolationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyILUTInterpolationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTLUTInterpolationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *)new std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTInterpolationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TLUTInterpolationMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTLUTInterpolationMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTLUTInterpolationMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTInterpolationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *)new std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTInterpolationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTLUTInterpolationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTLUTInterpolationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *)new std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode >((std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTInterpolationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTLUTInterpolationMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTLUTInterpolationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTLUTInterpolationMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTLUTInterpolationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTLUTInterpolationMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode >::pair(std::string,mvIMPACT::acquire::TLUTInterpolationMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode >::pair(std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTLUTInterpolationMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTInterpolationMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTInterpolationMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTLUTInterpolationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTLUTInterpolationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTInterpolationMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTInterpolationMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTInterpolationMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  mvIMPACT::acquire::TLUTInterpolationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTInterpolationMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTInterpolationMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTLUTInterpolationMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTInterpolationMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTInterpolationMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTInterpolationMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TLUTInterpolationMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTLUTInterpolationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTLUTInterpolationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTLUTInterpolationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTLUTInterpolationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyILUTMapping__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTMapping__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyILUTMapping" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTMapping__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyILUTMapping" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyILUTMapping" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTMapping(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyILUTMapping", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyILUTMapping__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyILUTMapping__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyILUTMapping__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyILUTMapping'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMapping >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTMapping_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TLUTMapping> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTMapping> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTMapping> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TLUTMapping>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TLUTMapping>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMapping_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTMapping_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILUTMapping_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTMapping_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTMapping_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTMapping result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMapping_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTMapping result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTMapping_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILUTMapping_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTMapping_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTMapping_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTMapping_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTMapping_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTMapping result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMapping_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTMapping result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTMapping result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTMapping result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTMapping result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMapping_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTMapping_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMapping_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMapping_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTMapping_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyILUTMapping_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMapping_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTMapping_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMapping_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTMapping_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyILUTMapping_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyILUTMapping_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTMapping_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTMapping_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTMapping_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyILUTMapping_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTMapping_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyILUTMapping_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTMapping_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::read(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::read(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::read(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::read(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::read(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::read(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  mvIMPACT::acquire::TLUTMapping arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMapping_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTMapping""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTMapping >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMapping_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  mvIMPACT::acquire::TLUTMapping arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMapping_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTMapping""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTMapping >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMapping_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMapping_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTMapping_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMapping_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMapping >* pV = new std::vector<mvIMPACT::acquire::TLUTMapping > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMapping_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMapping >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMapping>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTMapping_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTMapping_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTMapping_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyILUTMapping_write__SWIG_5(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyILUTMapping_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTMapping_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTMapping_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTMapping_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::write(mvIMPACT::acquire::TLUTMapping,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::write(mvIMPACT::acquire::TLUTMapping) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::write(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::write(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::write(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >::write(std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyILUTMapping(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyILUTMapping" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyILUTMapping_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyILUTMapping_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTLUTMapping__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *)new std::pair< std::string,mvIMPACT::acquire::TLUTMapping >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTMapping__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TLUTMapping arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTLUTMapping" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTLUTMapping" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTMapping""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTMapping >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *)new std::pair< std::string,mvIMPACT::acquire::TLUTMapping >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTMapping__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *ptr = (std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTLUTMapping" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMapping > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTLUTMapping" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMapping > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *)new std::pair< std::string,mvIMPACT::acquire::TLUTMapping >((std::pair< std::string,mvIMPACT::acquire::TLUTMapping > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTMapping(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTLUTMapping", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTLUTMapping__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTLUTMapping__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTLUTMapping__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTLUTMapping'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TLUTMapping >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTMapping >::pair(std::string,mvIMPACT::acquire::TLUTMapping)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTMapping >::pair(std::pair< std::string,mvIMPACT::acquire::TLUTMapping > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTLUTMapping_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTMapping_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTMapping_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTLUTMapping_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTLUTMapping_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTMapping_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTMapping_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTMapping_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *) 0 ;
  mvIMPACT::acquire::TLUTMapping arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTMapping_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTMapping_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTLUTMapping_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTMapping""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTMapping >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTMapping_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTMapping result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTMapping_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TLUTMapping) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTLUTMapping(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTLUTMapping" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTLUTMapping_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTLUTMapping_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyILUTMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyILUTMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyILUTMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyILUTMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyILUTMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyILUTMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyILUTMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyILUTMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyILUTMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyILUTMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TLUTMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TLUTMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TLUTMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TLUTMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTMode_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILUTMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyILUTMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyILUTMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TLUTMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TLUTMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; int arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; bool arg3 ; int arg4 ;
  int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyILUTMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; bool arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyILUTMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyILUTMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyILUTMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyILUTMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTMode_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::read(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::read(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::read(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::read(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::read(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::read(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  mvIMPACT::acquire::TLUTMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  mvIMPACT::acquire::TLUTMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyILUTMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; }  { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; bool arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyILUTMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyILUTMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TLUTMode >* pV = new std::vector<mvIMPACT::acquire::TLUTMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyILUTMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TLUTMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TLUTMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyILUTMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyILUTMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyILUTMode_write__SWIG_5(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyILUTMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyILUTMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyILUTMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyILUTMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::write(mvIMPACT::acquire::TLUTMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::write(mvIMPACT::acquire::TLUTMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::write(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::write(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::write(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >::write(std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyILUTMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyILUTMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyILUTMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyILUTMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTLUTMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTMode > *)new std::pair< std::string,mvIMPACT::acquire::TLUTMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TLUTMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TLUTMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTLUTMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTLUTMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTMode > *)new std::pair< std::string,mvIMPACT::acquire::TLUTMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TLUTMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TLUTMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TLUTMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TLUTMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTLUTMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTLUTMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TLUTMode > *)new std::pair< std::string,mvIMPACT::acquire::TLUTMode >((std::pair< std::string,mvIMPACT::acquire::TLUTMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTLUTMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTLUTMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTLUTMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTLUTMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTLUTMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTLUTMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TLUTMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTMode >::pair(std::string,mvIMPACT::acquire::TLUTMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TLUTMode >::pair(std::pair< std::string,mvIMPACT::acquire::TLUTMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTLUTMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTLUTMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTLUTMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMode > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMode > *) 0 ;
  mvIMPACT::acquire::TLUTMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTLUTMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTLUTMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TLUTMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TLUTMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->second = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTLUTMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TLUTMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTLUTMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMode > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::TLUTMode) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTLUTMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TLUTMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TLUTMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTLUTMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TLUTMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TLUTMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTLUTMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTLUTMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIMemoryManagerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMemoryManagerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIMemoryManagerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMemoryManagerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIMemoryManagerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIMemoryManagerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMemoryManagerMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIMemoryManagerMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIMemoryManagerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIMemoryManagerMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIMemoryManagerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIMemoryManagerMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TMemoryManagerMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TMemoryManagerMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TMemoryManagerMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TMemoryManagerMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TMemoryManagerMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMemoryManagerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TMemoryManagerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TMemoryManagerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMemoryManagerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TMemoryManagerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TMemoryManagerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMemoryManagerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMemoryManagerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMemoryManagerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIMemoryManagerMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMemoryManagerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  mvIMPACT::acquire::TMemoryManagerMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TMemoryManagerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMemoryManagerMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  mvIMPACT::acquire::TMemoryManagerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TMemoryManagerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMemoryManagerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIMemoryManagerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIMemoryManagerMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMemoryManagerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::write(mvIMPACT::acquire::TMemoryManagerMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::write(mvIMPACT::acquire::TMemoryManagerMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::write(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::write(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::write(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >::write(std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIMemoryManagerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIMemoryManagerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIMemoryManagerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIMemoryManagerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTMemoryManagerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *)new std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMemoryManagerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TMemoryManagerMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTMemoryManagerMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTMemoryManagerMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TMemoryManagerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMemoryManagerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *)new std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMemoryManagerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTMemoryManagerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTMemoryManagerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *)new std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode >((std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMemoryManagerMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTMemoryManagerMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTMemoryManagerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTMemoryManagerMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTMemoryManagerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTMemoryManagerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode >::pair(std::string,mvIMPACT::acquire::TMemoryManagerMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode >::pair(std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTMemoryManagerMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTMemoryManagerMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMemoryManagerMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTMemoryManagerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTMemoryManagerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMemoryManagerMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMemoryManagerMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMemoryManagerMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  mvIMPACT::acquire::TMemoryManagerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTMemoryManagerMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMemoryManagerMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTMemoryManagerMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TMemoryManagerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMemoryManagerMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMemoryManagerMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMemoryManagerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMemoryManagerMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TMemoryManagerMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTMemoryManagerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTMemoryManagerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTMemoryManagerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTMemoryManagerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIMemoryManagerPoolMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMemoryManagerPoolMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIMemoryManagerPoolMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMemoryManagerPoolMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIMemoryManagerPoolMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIMemoryManagerPoolMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMemoryManagerPoolMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIMemoryManagerPoolMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIMemoryManagerPoolMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIMemoryManagerPoolMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIMemoryManagerPoolMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIMemoryManagerPoolMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerPoolMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TMemoryManagerPoolMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TMemoryManagerPoolMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TMemoryManagerPoolMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TMemoryManagerPoolMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TMemoryManagerPoolMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerPoolMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMemoryManagerPoolMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TMemoryManagerPoolMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TMemoryManagerPoolMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerPoolMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMemoryManagerPoolMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerPoolMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerPoolMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TMemoryManagerPoolMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TMemoryManagerPoolMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMemoryManagerPoolMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMemoryManagerPoolMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMemoryManagerPoolMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerPoolMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerPoolMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMemoryManagerPoolMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::read(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  mvIMPACT::acquire::TMemoryManagerPoolMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TMemoryManagerPoolMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMemoryManagerPoolMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  mvIMPACT::acquire::TMemoryManagerPoolMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TMemoryManagerPoolMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMemoryManagerPoolMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >* pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMemoryManagerPoolMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMemoryManagerPoolMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMemoryManagerPoolMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMemoryManagerPoolMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::write(mvIMPACT::acquire::TMemoryManagerPoolMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::write(mvIMPACT::acquire::TMemoryManagerPoolMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::write(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::write(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::write(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >::write(std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIMemoryManagerPoolMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIMemoryManagerPoolMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIMemoryManagerPoolMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIMemoryManagerPoolMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTMemoryManagerPoolMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *)new std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMemoryManagerPoolMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TMemoryManagerPoolMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTMemoryManagerPoolMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTMemoryManagerPoolMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TMemoryManagerPoolMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMemoryManagerPoolMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *)new std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMemoryManagerPoolMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTMemoryManagerPoolMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTMemoryManagerPoolMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *)new std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode >((std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMemoryManagerPoolMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTMemoryManagerPoolMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTMemoryManagerPoolMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTMemoryManagerPoolMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTMemoryManagerPoolMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTMemoryManagerPoolMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode >::pair(std::string,mvIMPACT::acquire::TMemoryManagerPoolMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode >::pair(std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTMemoryManagerPoolMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTMemoryManagerPoolMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMemoryManagerPoolMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTMemoryManagerPoolMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTMemoryManagerPoolMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMemoryManagerPoolMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMemoryManagerPoolMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMemoryManagerPoolMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  mvIMPACT::acquire::TMemoryManagerPoolMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTMemoryManagerPoolMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMemoryManagerPoolMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTMemoryManagerPoolMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TMemoryManagerPoolMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMemoryManagerPoolMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMemoryManagerPoolMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMemoryManagerPoolMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMemoryManagerPoolMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TMemoryManagerPoolMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTMemoryManagerPoolMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTMemoryManagerPoolMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTMemoryManagerPoolMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTMemoryManagerPoolMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIMirrorMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMirrorMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIMirrorMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMirrorMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIMirrorMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIMirrorMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMirrorMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIMirrorMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIMirrorMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIMirrorMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIMirrorMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIMirrorMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMirrorMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TMirrorMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TMirrorMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TMirrorMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TMirrorMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TMirrorMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMirrorMode_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIMirrorMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMirrorMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TMirrorMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TMirrorMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMirrorMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIMirrorMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMirrorMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMirrorMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMirrorMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TMirrorMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TMirrorMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMirrorMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMirrorMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMirrorMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMirrorMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMirrorMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIMirrorMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMirrorMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMirrorMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIMirrorMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMirrorMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIMirrorMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMirrorMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::read(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::read(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::read(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::read(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::read(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::read(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  mvIMPACT::acquire::TMirrorMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TMirrorMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMirrorMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  mvIMPACT::acquire::TMirrorMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TMirrorMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMirrorMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMirrorMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMirrorMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIMirrorMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIMirrorMode_write__SWIG_5(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIMirrorMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIMirrorMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMirrorMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::write(mvIMPACT::acquire::TMirrorMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::write(mvIMPACT::acquire::TMirrorMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::write(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::write(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::write(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >::write(std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIMirrorMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIMirrorMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIMirrorMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIMirrorMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTMirrorMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *)new std::pair< std::string,mvIMPACT::acquire::TMirrorMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMirrorMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TMirrorMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTMirrorMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTMirrorMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TMirrorMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMirrorMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *)new std::pair< std::string,mvIMPACT::acquire::TMirrorMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMirrorMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTMirrorMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTMirrorMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *)new std::pair< std::string,mvIMPACT::acquire::TMirrorMode >((std::pair< std::string,mvIMPACT::acquire::TMirrorMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMirrorMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTMirrorMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTMirrorMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTMirrorMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTMirrorMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTMirrorMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TMirrorMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TMirrorMode >::pair(std::string,mvIMPACT::acquire::TMirrorMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TMirrorMode >::pair(std::pair< std::string,mvIMPACT::acquire::TMirrorMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTMirrorMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTMirrorMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMirrorMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTMirrorMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTMirrorMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMirrorMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMirrorMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMirrorMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *) 0 ;
  mvIMPACT::acquire::TMirrorMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTMirrorMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMirrorMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTMirrorMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TMirrorMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMirrorMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMirrorMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMirrorMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMirrorMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TMirrorMode) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTMirrorMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTMirrorMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTMirrorMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTMirrorMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIMirrorOperationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMirrorOperationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIMirrorOperationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMirrorOperationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIMirrorOperationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIMirrorOperationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIMirrorOperationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIMirrorOperationMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIMirrorOperationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIMirrorOperationMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIMirrorOperationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIMirrorOperationMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMirrorOperationMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TMirrorOperationMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TMirrorOperationMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TMirrorOperationMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TMirrorOperationMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TMirrorOperationMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorOperationMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMirrorOperationMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMirrorOperationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TMirrorOperationMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorOperationMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TMirrorOperationMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMirrorOperationMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMirrorOperationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMirrorOperationMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIMirrorOperationMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TMirrorOperationMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TMirrorOperationMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMirrorOperationMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMirrorOperationMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMirrorOperationMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorOperationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMirrorOperationMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIMirrorOperationMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMirrorOperationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::read(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::read(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::read(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::read(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::read(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::read(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  mvIMPACT::acquire::TMirrorOperationMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TMirrorOperationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMirrorOperationMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  mvIMPACT::acquire::TMirrorOperationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TMirrorOperationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMirrorOperationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TMirrorOperationMode >* pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIMirrorOperationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TMirrorOperationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TMirrorOperationMode>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIMirrorOperationMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIMirrorOperationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIMirrorOperationMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIMirrorOperationMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIMirrorOperationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::write(mvIMPACT::acquire::TMirrorOperationMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::write(mvIMPACT::acquire::TMirrorOperationMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::write(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::write(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::write(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >::write(std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIMirrorOperationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIMirrorOperationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIMirrorOperationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIMirrorOperationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTMirrorOperationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *)new std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMirrorOperationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TMirrorOperationMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTMirrorOperationMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTMirrorOperationMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TMirrorOperationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMirrorOperationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *)new std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMirrorOperationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTMirrorOperationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTMirrorOperationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *)new std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode >((std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTMirrorOperationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTMirrorOperationMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTMirrorOperationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTMirrorOperationMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTMirrorOperationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTMirrorOperationMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode >::pair(std::string,mvIMPACT::acquire::TMirrorOperationMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode >::pair(std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTMirrorOperationMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTMirrorOperationMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMirrorOperationMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTMirrorOperationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTMirrorOperationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMirrorOperationMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMirrorOperationMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMirrorOperationMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  mvIMPACT::acquire::TMirrorOperationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTMirrorOperationMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMirrorOperationMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTMirrorOperationMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TMirrorOperationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TMirrorOperationMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTMirrorOperationMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TMirrorOperationMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTMirrorOperationMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TMirrorOperationMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTMirrorOperationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTMirrorOperationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTMirrorOperationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTMirrorOperationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIOnBoardMemoryMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIOnBoardMemoryMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIOnBoardMemoryMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIOnBoardMemoryMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIOnBoardMemoryMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIOnBoardMemoryMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIOnBoardMemoryMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIOnBoardMemoryMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIOnBoardMemoryMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIOnBoardMemoryMode__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIOnBoardMemoryMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIOnBoardMemoryMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIOnBoardMemoryMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TOnBoardMemoryMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TOnBoardMemoryMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TOnBoardMemoryMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TOnBoardMemoryMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TOnBoardMemoryMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIOnBoardMemoryMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIOnBoardMemoryMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TOnBoardMemoryMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TOnBoardMemoryMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIOnBoardMemoryMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIOnBoardMemoryMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIOnBoardMemoryMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIOnBoardMemoryMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TOnBoardMemoryMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TOnBoardMemoryMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TOnBoardMemoryMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TOnBoardMemoryMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TOnBoardMemoryMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIOnBoardMemoryMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIOnBoardMemoryMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIOnBoardMemoryMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::read(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::read(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::read(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::read(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::read(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::read(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  mvIMPACT::acquire::TOnBoardMemoryMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TOnBoardMemoryMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TOnBoardMemoryMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  mvIMPACT::acquire::TOnBoardMemoryMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TOnBoardMemoryMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TOnBoardMemoryMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >* pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIOnBoardMemoryMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TOnBoardMemoryMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TOnBoardMemoryMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIOnBoardMemoryMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIOnBoardMemoryMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIOnBoardMemoryMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIOnBoardMemoryMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIOnBoardMemoryMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::write(mvIMPACT::acquire::TOnBoardMemoryMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::write(mvIMPACT::acquire::TOnBoardMemoryMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::write(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::write(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::write(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >::write(std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIOnBoardMemoryMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIOnBoardMemoryMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIOnBoardMemoryMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIOnBoardMemoryMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTOnBoardMemoryMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *)new std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTOnBoardMemoryMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TOnBoardMemoryMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTOnBoardMemoryMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTOnBoardMemoryMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TOnBoardMemoryMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TOnBoardMemoryMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *)new std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTOnBoardMemoryMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTOnBoardMemoryMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTOnBoardMemoryMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *)new std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode >((std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTOnBoardMemoryMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTOnBoardMemoryMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTOnBoardMemoryMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTOnBoardMemoryMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTOnBoardMemoryMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTOnBoardMemoryMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode >::pair(std::string,mvIMPACT::acquire::TOnBoardMemoryMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode >::pair(std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTOnBoardMemoryMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTOnBoardMemoryMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTOnBoardMemoryMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTOnBoardMemoryMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTOnBoardMemoryMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTOnBoardMemoryMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTOnBoardMemoryMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTOnBoardMemoryMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  mvIMPACT::acquire::TOnBoardMemoryMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTOnBoardMemoryMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTOnBoardMemoryMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTOnBoardMemoryMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TOnBoardMemoryMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TOnBoardMemoryMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTOnBoardMemoryMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TOnBoardMemoryMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTOnBoardMemoryMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TOnBoardMemoryMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTOnBoardMemoryMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTOnBoardMemoryMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTOnBoardMemoryMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTOnBoardMemoryMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIPolarizedDataExtractionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIPolarizedDataExtractionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIPolarizedDataExtractionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIPolarizedDataExtractionMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIPolarizedDataExtractionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIPolarizedDataExtractionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIPolarizedDataExtractionMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIPolarizedDataExtractionMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIPolarizedDataExtractionMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIPolarizedDataExtractionMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIPolarizedDataExtractionMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIPolarizedDataExtractionMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TPolarizedDataExtractionMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPolarizedDataExtractionMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TPolarizedDataExtractionMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPolarizedDataExtractionMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TPolarizedDataExtractionMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPolarizedDataExtractionMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPolarizedDataExtractionMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPolarizedDataExtractionMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPolarizedDataExtractionMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TPolarizedDataExtractionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPolarizedDataExtractionMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TPolarizedDataExtractionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPolarizedDataExtractionMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPolarizedDataExtractionMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::write(mvIMPACT::acquire::TPolarizedDataExtractionMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::write(mvIMPACT::acquire::TPolarizedDataExtractionMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::write(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::write(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::write(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >::write(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIPolarizedDataExtractionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIPolarizedDataExtractionMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIPolarizedDataExtractionMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIPolarizedDataExtractionMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTPolarizedDataExtractionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *)new std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTPolarizedDataExtractionMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TPolarizedDataExtractionMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTPolarizedDataExtractionMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTPolarizedDataExtractionMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TPolarizedDataExtractionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPolarizedDataExtractionMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *)new std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTPolarizedDataExtractionMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTPolarizedDataExtractionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTPolarizedDataExtractionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *)new std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode >((std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTPolarizedDataExtractionMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTPolarizedDataExtractionMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTPolarizedDataExtractionMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTPolarizedDataExtractionMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTPolarizedDataExtractionMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTPolarizedDataExtractionMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode >::pair(std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode >::pair(std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTPolarizedDataExtractionMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTPolarizedDataExtractionMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPolarizedDataExtractionMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTPolarizedDataExtractionMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTPolarizedDataExtractionMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTPolarizedDataExtractionMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPolarizedDataExtractionMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTPolarizedDataExtractionMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTPolarizedDataExtractionMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPolarizedDataExtractionMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTPolarizedDataExtractionMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TPolarizedDataExtractionMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPolarizedDataExtractionMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTPolarizedDataExtractionMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPolarizedDataExtractionMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPolarizedDataExtractionMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TPolarizedDataExtractionMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTPolarizedDataExtractionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTPolarizedDataExtractionMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTPolarizedDataExtractionMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTPolarizedDataExtractionMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIPolarizedDataExtractionInterpolationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIPolarizedDataExtractionInterpolationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIPolarizedDataExtractionInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIPolarizedDataExtractionInterpolationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIPolarizedDataExtractionInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIPolarizedDataExtractionInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &""'"); }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIPolarizedDataExtractionInterpolationMode(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIPolarizedDataExtractionInterpolationMode", 0, 1, argv))) SWIG_fail;
  --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIPolarizedDataExtractionInterpolationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIPolarizedDataExtractionInterpolationMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIPolarizedDataExtractionInterpolationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIPolarizedDataExtractionInterpolationMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionInterpolationMode_read", 0, 5, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPolarizedDataExtractionInterpolationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::read(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >(val2); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>( *i ) ) )
      { SWIG_fail; }  }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPolarizedDataExtractionInterpolationMode_write", 0, 4, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPolarizedDataExtractionInterpolationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::write(mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::write(mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::write(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::write(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::write(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::write(std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIPolarizedDataExtractionInterpolationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIPolarizedDataExtractionInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *""'");  }
  
  arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIPolarizedDataExtractionInterpolationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIPolarizedDataExtractionInterpolationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTPolarizedDataExtractionInterpolationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *)new std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTPolarizedDataExtractionInterpolationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode arg2 ; int val2 ;
  int ecode2 = 0 ; std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTPolarizedDataExtractionInterpolationMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTPolarizedDataExtractionInterpolationMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >(val2); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *)new std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTPolarizedDataExtractionInterpolationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTPolarizedDataExtractionInterpolationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTPolarizedDataExtractionInterpolationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *)new std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >((std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTPolarizedDataExtractionInterpolationMode(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTPolarizedDataExtractionInterpolationMode", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTPolarizedDataExtractionInterpolationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTPolarizedDataExtractionInterpolationMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTPolarizedDataExtractionInterpolationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTPolarizedDataExtractionInterpolationMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::pair(std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >::pair(std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTPolarizedDataExtractionInterpolationMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTPolarizedDataExtractionInterpolationMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPolarizedDataExtractionInterpolationMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTPolarizedDataExtractionInterpolationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTPolarizedDataExtractionInterpolationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTPolarizedDataExtractionInterpolationMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPolarizedDataExtractionInterpolationMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTPolarizedDataExtractionInterpolationMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ;
  int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTPolarizedDataExtractionInterpolationMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPolarizedDataExtractionInterpolationMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTPolarizedDataExtractionInterpolationMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTPolarizedDataExtractionInterpolationMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPolarizedDataExtractionInterpolationMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTPolarizedDataExtractionInterpolationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTPolarizedDataExtractionInterpolationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTPolarizedDataExtractionInterpolationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTPolarizedDataExtractionInterpolationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIPulseStartTrigger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIPulseStartTrigger__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIPulseStartTrigger" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIPulseStartTrigger__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIPulseStartTrigger" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIPulseStartTrigger" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIPulseStartTrigger(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIPulseStartTrigger", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIPulseStartTrigger__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIPulseStartTrigger__SWIG_2(self, argc, argv);}
   check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIPulseStartTrigger__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIPulseStartTrigger'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIPulseStartTrigger_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TPulseStartTrigger> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TPulseStartTrigger> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TPulseStartTrigger> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TPulseStartTrigger>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TPulseStartTrigger>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPulseStartTrigger_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPulseStartTrigger_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPulseStartTrigger_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TPulseStartTrigger result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPulseStartTrigger_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TPulseStartTrigger result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPulseStartTrigger_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPulseStartTrigger_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIPulseStartTrigger_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIPulseStartTrigger_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TPulseStartTrigger result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TPulseStartTrigger result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPulseStartTrigger result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPulseStartTrigger result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPulseStartTrigger result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPulseStartTrigger_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPulseStartTrigger_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIPulseStartTrigger_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPulseStartTrigger_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::read(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::read(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::read(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::read(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::read(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::read(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  mvIMPACT::acquire::TPulseStartTrigger arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TPulseStartTrigger""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPulseStartTrigger >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  mvIMPACT::acquire::TPulseStartTrigger arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TPulseStartTrigger""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPulseStartTrigger >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TPulseStartTrigger >* pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIPulseStartTrigger_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TPulseStartTrigger >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TPulseStartTrigger>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIPulseStartTrigger_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIPulseStartTrigger_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIPulseStartTrigger_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIPulseStartTrigger_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIPulseStartTrigger_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::write(mvIMPACT::acquire::TPulseStartTrigger,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::write(mvIMPACT::acquire::TPulseStartTrigger) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::write(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::write(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::write(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >::write(std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIPulseStartTrigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIPulseStartTrigger" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIPulseStartTrigger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIPulseStartTrigger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTPulseStartTrigger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *)new std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTPulseStartTrigger__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TPulseStartTrigger arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTPulseStartTrigger" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTPulseStartTrigger" "', argument " "2"" of type '" "mvIMPACT::acquire::TPulseStartTrigger""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPulseStartTrigger >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *)new std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTPulseStartTrigger__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *ptr = (std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTPulseStartTrigger" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTPulseStartTrigger" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *)new std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger >((std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTPulseStartTrigger(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTPulseStartTrigger", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTPulseStartTrigger__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTPulseStartTrigger__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTPulseStartTrigger__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTPulseStartTrigger'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger >::pair(std::string,mvIMPACT::acquire::TPulseStartTrigger)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger >::pair(std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTPulseStartTrigger_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTPulseStartTrigger_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPulseStartTrigger_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTPulseStartTrigger_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTPulseStartTrigger_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTPulseStartTrigger_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPulseStartTrigger_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTPulseStartTrigger_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  mvIMPACT::acquire::TPulseStartTrigger arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTPulseStartTrigger_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPulseStartTrigger_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTPulseStartTrigger_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TPulseStartTrigger""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TPulseStartTrigger >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTPulseStartTrigger_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TPulseStartTrigger result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTPulseStartTrigger_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TPulseStartTrigger) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTPulseStartTrigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTPulseStartTrigger" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTPulseStartTrigger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTPulseStartTrigger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIRequestResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRequestResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIRequestResult" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRequestResult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIRequestResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIRequestResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRequestResult(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIRequestResult", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIRequestResult__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIRequestResult__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIRequestResult__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIRequestResult'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRequestResult > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRequestResult_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TRequestResult> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TRequestResult> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TRequestResult> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TRequestResult>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TRequestResult>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestResult_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestResult_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRequestResult_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestResult_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestResult_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRequestResult result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestResult_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRequestResult result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestResult_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRequestResult_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestResult_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestResult_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRequestResult_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRequestResult_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRequestResult result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestResult_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRequestResult result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestResult result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestResult result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestResult result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestResult_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestResult_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIRequestResult_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestResult_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestResult_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestResult_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRequestResult_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRequestResult_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestResult_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRequestResult_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRequestResult_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIRequestResult_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRequestResult_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIRequestResult_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestResult_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::read(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::read(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::read(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::read(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::read(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::read(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  mvIMPACT::acquire::TRequestResult arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestResult_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestResult >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestResult_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  mvIMPACT::acquire::TRequestResult arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestResult_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestResult >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestResult_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestResult_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestResult_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestResult_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestResult >* pV = new std::vector<mvIMPACT::acquire::TRequestResult > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestResult_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestResult >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestResult>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestResult_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRequestResult_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestResult_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRequestResult_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIRequestResult_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRequestResult_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRequestResult_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestResult_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::write(mvIMPACT::acquire::TRequestResult,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::write(mvIMPACT::acquire::TRequestResult) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::write(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::write(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::write(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >::write(std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIRequestResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIRequestResult" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIRequestResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIRequestResult_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTRequestResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRequestResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRequestResult > *)new std::pair< std::string,mvIMPACT::acquire::TRequestResult >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRequestResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TRequestResult arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TRequestResult > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTRequestResult" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTRequestResult" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestResult >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRequestResult > *)new std::pair< std::string,mvIMPACT::acquire::TRequestResult >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRequestResult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRequestResult > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TRequestResult > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TRequestResult > *ptr = (std::pair< std::string,mvIMPACT::acquire::TRequestResult > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTRequestResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestResult > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTRequestResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestResult > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRequestResult > *)new std::pair< std::string,mvIMPACT::acquire::TRequestResult >((std::pair< std::string,mvIMPACT::acquire::TRequestResult > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRequestResult(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTRequestResult", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTRequestResult__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTRequestResult__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTRequestResult__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTRequestResult'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TRequestResult >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRequestResult >::pair(std::string,mvIMPACT::acquire::TRequestResult)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRequestResult >::pair(std::pair< std::string,mvIMPACT::acquire::TRequestResult > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTRequestResult_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestResult > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRequestResult_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestResult_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestResult > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTRequestResult_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTRequestResult_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRequestResult_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestResult_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestResult > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRequestResult_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestResult > *) 0 ;
  mvIMPACT::acquire::TRequestResult arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRequestResult_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestResult_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestResult > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTRequestResult_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestResult""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestResult >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRequestResult_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestResult result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestResult_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestResult > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TRequestResult) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTRequestResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestResult > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestResult > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTRequestResult" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestResult > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestResult > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTRequestResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTRequestResult_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIRequestState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRequestState__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIRequestState" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRequestState__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIRequestState" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIRequestState" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRequestState(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIRequestState", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIRequestState__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIRequestState__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIRequestState__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIRequestState'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestState >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRequestState > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRequestState_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TRequestState> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TRequestState> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TRequestState> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TRequestState>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TRequestState>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestState_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestState_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRequestState_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestState_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestState_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRequestState result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestState_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRequestState result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestState_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRequestState_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestState_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestState_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRequestState_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRequestState_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRequestState result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestState_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRequestState result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestState_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestState_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestState_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestState_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestState_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIRequestState_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestState_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestState_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestState_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestState_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIRequestState_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRequestState_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestState_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRequestState_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRequestState_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIRequestState_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRequestState_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIRequestState_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestState_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::read(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::read(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::read(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::read(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::read(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::read(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  mvIMPACT::acquire::TRequestState arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestState_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestState >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestState_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  mvIMPACT::acquire::TRequestState arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRequestState_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestState >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestState_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestState_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRequestState_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRequestState_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRequestState >* pV = new std::vector<mvIMPACT::acquire::TRequestState > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRequestState_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRequestState >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRequestState>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRequestState_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRequestState_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRequestState_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRequestState_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIRequestState_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRequestState_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRequestState_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRequestState_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::write(mvIMPACT::acquire::TRequestState,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::write(mvIMPACT::acquire::TRequestState) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::write(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::write(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::write(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >::write(std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIRequestState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIRequestState" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIRequestState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIRequestState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTRequestState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRequestState > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRequestState > *)new std::pair< std::string,mvIMPACT::acquire::TRequestState >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRequestState__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TRequestState arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TRequestState > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTRequestState" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTRequestState" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestState >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRequestState > *)new std::pair< std::string,mvIMPACT::acquire::TRequestState >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRequestState__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRequestState > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TRequestState > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TRequestState > *ptr = (std::pair< std::string,mvIMPACT::acquire::TRequestState > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTRequestState" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestState > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTRequestState" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestState > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRequestState > *)new std::pair< std::string,mvIMPACT::acquire::TRequestState >((std::pair< std::string,mvIMPACT::acquire::TRequestState > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRequestState(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTRequestState", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTRequestState__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTRequestState__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTRequestState__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTRequestState'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TRequestState >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRequestState >::pair(std::string,mvIMPACT::acquire::TRequestState)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRequestState >::pair(std::pair< std::string,mvIMPACT::acquire::TRequestState > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTRequestState_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestState > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRequestState_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestState_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestState > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTRequestState_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTRequestState_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRequestState_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestState_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestState > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRequestState_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestState > *) 0 ;
  mvIMPACT::acquire::TRequestState arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRequestState_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestState_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestState > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTRequestState_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TRequestState""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRequestState >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRequestState_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRequestState result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRequestState_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestState > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TRequestState) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTRequestState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRequestState > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRequestState > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTRequestState" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRequestState > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRequestState > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTRequestState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTRequestState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIRTCtrlModes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRTCtrlModes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIRTCtrlModes" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRTCtrlModes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIRTCtrlModes" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIRTCtrlModes" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRTCtrlModes(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIRTCtrlModes", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIRTCtrlModes__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIRTCtrlModes__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIRTCtrlModes__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIRTCtrlModes'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRTCtrlModes_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TRTCtrlModes> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TRTCtrlModes> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TRTCtrlModes> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TRTCtrlModes>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TRTCtrlModes>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTCtrlModes_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRTCtrlModes_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRTCtrlModes_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRTCtrlModes_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRTCtrlModes result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTCtrlModes_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRTCtrlModes result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRTCtrlModes_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRTCtrlModes_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRTCtrlModes_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRTCtrlModes_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRTCtrlModes_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRTCtrlModes result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTCtrlModes_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRTCtrlModes result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRTCtrlModes result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRTCtrlModes result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRTCtrlModes result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTCtrlModes_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRTCtrlModes_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTCtrlModes_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTCtrlModes_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRTCtrlModes_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIRTCtrlModes_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTCtrlModes_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRTCtrlModes_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTCtrlModes_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRTCtrlModes_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRTCtrlModes_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRTCtrlModes_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRTCtrlModes_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::read(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::read(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::read(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::read(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::read(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::read(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  mvIMPACT::acquire::TRTCtrlModes arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTCtrlModes_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRTCtrlModes""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRTCtrlModes >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTCtrlModes_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  mvIMPACT::acquire::TRTCtrlModes arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTCtrlModes_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRTCtrlModes""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRTCtrlModes >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTCtrlModes_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTCtrlModes_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRTCtrlModes_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTCtrlModes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTCtrlModes >* pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTCtrlModes_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTCtrlModes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTCtrlModes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRTCtrlModes_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRTCtrlModes_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRTCtrlModes_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRTCtrlModes_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRTCtrlModes_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::write(mvIMPACT::acquire::TRTCtrlModes,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::write(mvIMPACT::acquire::TRTCtrlModes) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::write(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::write(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::write(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >::write(std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIRTCtrlModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIRTCtrlModes" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIRTCtrlModes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIRTCtrlModes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTRTCtrlModes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *)new std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRTCtrlModes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TRTCtrlModes arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTRTCtrlModes" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTRTCtrlModes" "', argument " "2"" of type '" "mvIMPACT::acquire::TRTCtrlModes""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRTCtrlModes >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *)new std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRTCtrlModes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *ptr = (std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTRTCtrlModes" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTRTCtrlModes" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *)new std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes >((std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRTCtrlModes(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTRTCtrlModes", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTRTCtrlModes__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTRTCtrlModes__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTRTCtrlModes__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTRTCtrlModes'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes >::pair(std::string,mvIMPACT::acquire::TRTCtrlModes)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes >::pair(std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTRTCtrlModes_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRTCtrlModes_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRTCtrlModes_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTRTCtrlModes_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTRTCtrlModes_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRTCtrlModes_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRTCtrlModes_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRTCtrlModes_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  mvIMPACT::acquire::TRTCtrlModes arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRTCtrlModes_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRTCtrlModes_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTRTCtrlModes_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TRTCtrlModes""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRTCtrlModes >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRTCtrlModes_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRTCtrlModes result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRTCtrlModes_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TRTCtrlModes) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTRTCtrlModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTRTCtrlModes" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTRTCtrlModes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTRTCtrlModes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIRTProgOpCodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRTProgOpCodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIRTProgOpCodes" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRTProgOpCodes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIRTProgOpCodes" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIRTProgOpCodes" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIRTProgOpCodes(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIRTProgOpCodes", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIRTProgOpCodes__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIRTProgOpCodes__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIRTProgOpCodes__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIRTProgOpCodes'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRTProgOpCodes_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TRTProgOpCodes> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TRTProgOpCodes> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TRTProgOpCodes> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TRTProgOpCodes>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TRTProgOpCodes>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTProgOpCodes_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRTProgOpCodes_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRTProgOpCodes_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRTProgOpCodes_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRTProgOpCodes result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTProgOpCodes_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRTProgOpCodes result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRTProgOpCodes_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRTProgOpCodes_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRTProgOpCodes_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRTProgOpCodes_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIRTProgOpCodes_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TRTProgOpCodes result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TRTProgOpCodes result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRTProgOpCodes result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRTProgOpCodes result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRTProgOpCodes result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTProgOpCodes_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRTProgOpCodes_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIRTProgOpCodes_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRTProgOpCodes_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::read(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::read(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::read(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::read(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::read(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::read(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  mvIMPACT::acquire::TRTProgOpCodes arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRTProgOpCodes""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRTProgOpCodes >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  mvIMPACT::acquire::TRTProgOpCodes arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TRTProgOpCodes""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRTProgOpCodes >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TRTProgOpCodes >* pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIRTProgOpCodes_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TRTProgOpCodes >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TRTProgOpCodes>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIRTProgOpCodes_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRTProgOpCodes_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRTProgOpCodes_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIRTProgOpCodes_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIRTProgOpCodes_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::write(mvIMPACT::acquire::TRTProgOpCodes,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::write(mvIMPACT::acquire::TRTProgOpCodes) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::write(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::write(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::write(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >::write(std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIRTProgOpCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIRTProgOpCodes" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIRTProgOpCodes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIRTProgOpCodes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTRTProgOpCodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *)new std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRTProgOpCodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TRTProgOpCodes arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTRTProgOpCodes" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTRTProgOpCodes" "', argument " "2"" of type '" "mvIMPACT::acquire::TRTProgOpCodes""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRTProgOpCodes >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *)new std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRTProgOpCodes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *ptr = (std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTRTProgOpCodes" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTRTProgOpCodes" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *)new std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes >((std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTRTProgOpCodes(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTRTProgOpCodes", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTRTProgOpCodes__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTRTProgOpCodes__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTRTProgOpCodes__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTRTProgOpCodes'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes >::pair(std::string,mvIMPACT::acquire::TRTProgOpCodes)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes >::pair(std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTRTProgOpCodes_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRTProgOpCodes_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRTProgOpCodes_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTRTProgOpCodes_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTRTProgOpCodes_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRTProgOpCodes_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRTProgOpCodes_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRTProgOpCodes_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  mvIMPACT::acquire::TRTProgOpCodes arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTRTProgOpCodes_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRTProgOpCodes_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTRTProgOpCodes_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TRTProgOpCodes""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TRTProgOpCodes >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTRTProgOpCodes_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TRTProgOpCodes result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTRTProgOpCodes_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TRTProgOpCodes) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTRTProgOpCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTRTProgOpCodes" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTRTProgOpCodes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTRTProgOpCodes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIScalerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScalerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIScalerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScalerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIScalerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIScalerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScalerMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIScalerMode", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIScalerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIScalerMode__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIScalerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIScalerMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScalerMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScalerMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TScalerMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TScalerMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TScalerMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TScalerMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TScalerMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScalerMode_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIScalerMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScalerMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScalerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TScalerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TScalerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScalerMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIScalerMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScalerMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScalerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScalerMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScalerMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TScalerMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TScalerMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScalerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScalerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScalerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScalerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScalerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIScalerMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScalerMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScalerMode_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIScalerMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIScalerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScalerMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScalerMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIScalerMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIScalerMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIScalerMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIScalerMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScalerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::read(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::read(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::read(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::read(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::read(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::read(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  mvIMPACT::acquire::TScalerMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TScalerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScalerMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  mvIMPACT::acquire::TScalerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TScalerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScalerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScalerMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerMode >* pV = new std::vector<mvIMPACT::acquire::TScalerMode > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerMode>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScalerMode_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIScalerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScalerMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIScalerMode_write__SWIG_5(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIScalerMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIScalerMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIScalerMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScalerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::write(mvIMPACT::acquire::TScalerMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::write(mvIMPACT::acquire::TScalerMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::write(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::write(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::write(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >::write(std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIScalerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIScalerMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIScalerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIScalerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTScalerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TScalerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScalerMode > *)new std::pair< std::string,mvIMPACT::acquire::TScalerMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScalerMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TScalerMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TScalerMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTScalerMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTScalerMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TScalerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScalerMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScalerMode > *)new std::pair< std::string,mvIMPACT::acquire::TScalerMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScalerMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TScalerMode > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TScalerMode > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TScalerMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TScalerMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTScalerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTScalerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScalerMode > *)new std::pair< std::string,mvIMPACT::acquire::TScalerMode >((std::pair< std::string,mvIMPACT::acquire::TScalerMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScalerMode(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTScalerMode", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTScalerMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTScalerMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTScalerMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTScalerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TScalerMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TScalerMode >::pair(std::string,mvIMPACT::acquire::TScalerMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TScalerMode >::pair(std::pair< std::string,mvIMPACT::acquire::TScalerMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTScalerMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTScalerMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScalerMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTScalerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTScalerMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScalerMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScalerMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScalerMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerMode > *) 0 ;
  mvIMPACT::acquire::TScalerMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTScalerMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScalerMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTScalerMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TScalerMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScalerMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScalerMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScalerMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScalerMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TScalerMode) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTScalerMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTScalerMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTScalerMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTScalerMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIScalerInterpolationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScalerInterpolationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIScalerInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScalerInterpolationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIScalerInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIScalerInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScalerInterpolationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIScalerInterpolationMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIScalerInterpolationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIScalerInterpolationMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIScalerInterpolationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIScalerInterpolationMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScalerInterpolationMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TScalerInterpolationMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TScalerInterpolationMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TScalerInterpolationMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TScalerInterpolationMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TScalerInterpolationMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerInterpolationMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScalerInterpolationMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScalerInterpolationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TScalerInterpolationMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerInterpolationMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TScalerInterpolationMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScalerInterpolationMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScalerInterpolationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScalerInterpolationMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScalerInterpolationMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TScalerInterpolationMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TScalerInterpolationMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScalerInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScalerInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScalerInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerInterpolationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScalerInterpolationMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIScalerInterpolationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScalerInterpolationMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScalerInterpolationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::read(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::read(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::read(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::read(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::read(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::read(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  mvIMPACT::acquire::TScalerInterpolationMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TScalerInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScalerInterpolationMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  mvIMPACT::acquire::TScalerInterpolationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TScalerInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScalerInterpolationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode >* pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScalerInterpolationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScalerInterpolationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScalerInterpolationMode>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScalerInterpolationMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIScalerInterpolationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIScalerInterpolationMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIScalerInterpolationMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScalerInterpolationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::write(mvIMPACT::acquire::TScalerInterpolationMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::write(mvIMPACT::acquire::TScalerInterpolationMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::write(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::write(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::write(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >::write(std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIScalerInterpolationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIScalerInterpolationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIScalerInterpolationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIScalerInterpolationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTScalerInterpolationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *)new std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScalerInterpolationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TScalerInterpolationMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  { std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTScalerInterpolationMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTScalerInterpolationMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TScalerInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScalerInterpolationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *)new std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScalerInterpolationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTScalerInterpolationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTScalerInterpolationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *)new std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode >((std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScalerInterpolationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTScalerInterpolationMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTScalerInterpolationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTScalerInterpolationMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTScalerInterpolationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTScalerInterpolationMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode >::pair(std::string,mvIMPACT::acquire::TScalerInterpolationMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode >::pair(std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTScalerInterpolationMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTScalerInterpolationMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScalerInterpolationMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTScalerInterpolationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTScalerInterpolationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScalerInterpolationMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScalerInterpolationMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScalerInterpolationMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  mvIMPACT::acquire::TScalerInterpolationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTScalerInterpolationMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScalerInterpolationMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTScalerInterpolationMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TScalerInterpolationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScalerInterpolationMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScalerInterpolationMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScalerInterpolationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScalerInterpolationMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TScalerInterpolationMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTScalerInterpolationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTScalerInterpolationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTScalerInterpolationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTScalerInterpolationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIScanClock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScanClock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIScanClock" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScanClock__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIScanClock" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIScanClock" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScanClock(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIScanClock", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIScanClock__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIScanClock__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIScanClock__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIScanClock'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TScanClock >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScanClock > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScanClock_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TScanClock> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TScanClock> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TScanClock> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TScanClock>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TScanClock>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanClock_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScanClock_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIScanClock_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScanClock_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScanClock_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TScanClock result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanClock_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TScanClock result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScanClock_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIScanClock_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScanClock_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScanClock_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScanClock_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScanClock_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; }  { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TScanClock result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanClock_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TScanClock result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScanClock result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScanClock result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScanClock result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; int arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanClock_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScanClock_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanClock_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; }  { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanClock_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScanClock_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIScanClock_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanClock_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScanClock_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanClock_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScanClock_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIScanClock_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIScanClock_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScanClock_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScanClock_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIScanClock_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIScanClock_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIScanClock_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIScanClock_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScanClock_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::read(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::read(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::read(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::read(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::read(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::read(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  mvIMPACT::acquire::TScanClock arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanClock_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TScanClock""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScanClock >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanClock_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  mvIMPACT::acquire::TScanClock arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanClock_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TScanClock""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScanClock >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanClock_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; }  { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanClock_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScanClock_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanClock_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanClock >* pV = new std::vector<mvIMPACT::acquire::TScanClock > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanClock_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanClock >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanClock>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScanClock_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIScanClock_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScanClock_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIScanClock_write__SWIG_5(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIScanClock_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIScanClock_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIScanClock_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScanClock_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::write(mvIMPACT::acquire::TScanClock,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::write(mvIMPACT::acquire::TScanClock) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::write(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::write(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::write(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >::write(std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIScanClock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIScanClock" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIScanClock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIScanClock_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTScanClock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TScanClock > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScanClock > *)new std::pair< std::string,mvIMPACT::acquire::TScanClock >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScanClock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TScanClock arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TScanClock > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTScanClock" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTScanClock" "', argument " "2"" of type '" "mvIMPACT::acquire::TScanClock""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScanClock >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScanClock > *)new std::pair< std::string,mvIMPACT::acquire::TScanClock >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScanClock__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TScanClock > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TScanClock > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TScanClock > *ptr = (std::pair< std::string,mvIMPACT::acquire::TScanClock > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTScanClock" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanClock > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTScanClock" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanClock > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScanClock > *)new std::pair< std::string,mvIMPACT::acquire::TScanClock >((std::pair< std::string,mvIMPACT::acquire::TScanClock > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScanClock(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTScanClock", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringTScanClock__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTScanClock__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTScanClock__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTScanClock'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TScanClock >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TScanClock >::pair(std::string,mvIMPACT::acquire::TScanClock)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TScanClock >::pair(std::pair< std::string,mvIMPACT::acquire::TScanClock > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTScanClock_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanClock > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTScanClock_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScanClock_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanClock > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTScanClock_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTScanClock_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScanClock_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScanClock_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanClock > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScanClock_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanClock > *) 0 ;
  mvIMPACT::acquire::TScanClock arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTScanClock_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScanClock_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanClock > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTScanClock_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TScanClock""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScanClock >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScanClock_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScanClock result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScanClock_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanClock > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::TScanClock) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTScanClock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanClock > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanClock > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTScanClock" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanClock > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanClock > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTScanClock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTScanClock_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIScanStandard__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScanStandard__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIScanStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScanStandard__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIScanStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIScanStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIScanStandard(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIScanStandard", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIScanStandard__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIScanStandard__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIScanStandard__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIScanStandard'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TScanStandard >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScanStandard > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScanStandard_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TScanStandard> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TScanStandard> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TScanStandard> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TScanStandard>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TScanStandard>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanStandard_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScanStandard_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIScanStandard_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScanStandard_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScanStandard_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TScanStandard result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanStandard_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TScanStandard result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScanStandard_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIScanStandard_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScanStandard_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScanStandard_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScanStandard_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIScanStandard_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TScanStandard result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanStandard_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TScanStandard result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScanStandard result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScanStandard result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScanStandard result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanStandard_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScanStandard_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanStandard_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanStandard_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScanStandard_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIScanStandard_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanStandard_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScanStandard_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanStandard_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScanStandard_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIScanStandard_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIScanStandard_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScanStandard_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScanStandard_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIScanStandard_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIScanStandard_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIScanStandard_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIScanStandard_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScanStandard_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::read(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::read(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::read(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::read(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::read(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::read(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  mvIMPACT::acquire::TScanStandard arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanStandard_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TScanStandard""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScanStandard >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanStandard_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  mvIMPACT::acquire::TScanStandard arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIScanStandard_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TScanStandard""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScanStandard >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanStandard_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanStandard_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIScanStandard_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIScanStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TScanStandard >* pV = new std::vector<mvIMPACT::acquire::TScanStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIScanStandard_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TScanStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TScanStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIScanStandard_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIScanStandard_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIScanStandard_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIScanStandard_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIScanStandard_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIScanStandard_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIScanStandard_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIScanStandard_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::write(mvIMPACT::acquire::TScanStandard,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::write(mvIMPACT::acquire::TScanStandard) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::write(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::write(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::write(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >::write(std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIScanStandard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIScanStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIScanStandard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIScanStandard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTScanStandard__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TScanStandard > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScanStandard > *)new std::pair< std::string,mvIMPACT::acquire::TScanStandard >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScanStandard__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TScanStandard arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TScanStandard > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTScanStandard" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTScanStandard" "', argument " "2"" of type '" "mvIMPACT::acquire::TScanStandard""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScanStandard >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScanStandard > *)new std::pair< std::string,mvIMPACT::acquire::TScanStandard >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScanStandard__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TScanStandard > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TScanStandard > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TScanStandard > *ptr = (std::pair< std::string,mvIMPACT::acquire::TScanStandard > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTScanStandard" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanStandard > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTScanStandard" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanStandard > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TScanStandard > *)new std::pair< std::string,mvIMPACT::acquire::TScanStandard >((std::pair< std::string,mvIMPACT::acquire::TScanStandard > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTScanStandard(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTScanStandard", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTScanStandard__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTScanStandard__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTScanStandard__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTScanStandard'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TScanStandard >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TScanStandard >::pair(std::string,mvIMPACT::acquire::TScanStandard)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TScanStandard >::pair(std::pair< std::string,mvIMPACT::acquire::TScanStandard > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTScanStandard_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanStandard > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTScanStandard_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScanStandard_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanStandard > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTScanStandard_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTScanStandard_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScanStandard_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScanStandard_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanStandard > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScanStandard_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanStandard > *) 0 ;
  mvIMPACT::acquire::TScanStandard arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTScanStandard_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScanStandard_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTScanStandard_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TScanStandard""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TScanStandard >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTScanStandard_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TScanStandard result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTScanStandard_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanStandard > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TScanStandard) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTScanStandard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TScanStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TScanStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTScanStandard" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TScanStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TScanStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTScanStandard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTScanStandard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyITriggerMoment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyITriggerMoment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyITriggerMoment" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyITriggerMoment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyITriggerMoment" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyITriggerMoment" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyITriggerMoment(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyITriggerMoment", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyITriggerMoment__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyITriggerMoment__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyITriggerMoment__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyITriggerMoment'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyITriggerMoment_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TTriggerMoment> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TTriggerMoment> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TTriggerMoment> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TTriggerMoment>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TTriggerMoment>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyITriggerMoment_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyITriggerMoment_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyITriggerMoment_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyITriggerMoment_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyITriggerMoment_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TTriggerMoment result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyITriggerMoment_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TTriggerMoment result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyITriggerMoment_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyITriggerMoment_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyITriggerMoment_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyITriggerMoment_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyITriggerMoment_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyITriggerMoment_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TTriggerMoment result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyITriggerMoment_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TTriggerMoment result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TTriggerMoment result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TTriggerMoment result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TTriggerMoment result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyITriggerMoment_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyITriggerMoment_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyITriggerMoment_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyITriggerMoment_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyITriggerMoment_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyITriggerMoment_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyITriggerMoment_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyITriggerMoment_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyITriggerMoment_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyITriggerMoment_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyITriggerMoment_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyITriggerMoment_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyITriggerMoment_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyITriggerMoment_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyITriggerMoment_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyITriggerMoment_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyITriggerMoment_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyITriggerMoment_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyITriggerMoment_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::read(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::read(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::read(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::read(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::read(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::read(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  mvIMPACT::acquire::TTriggerMoment arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyITriggerMoment_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TTriggerMoment""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TTriggerMoment >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyITriggerMoment_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  mvIMPACT::acquire::TTriggerMoment arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyITriggerMoment_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TTriggerMoment""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TTriggerMoment >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyITriggerMoment_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write((std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write((std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyITriggerMoment_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyITriggerMoment_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write((std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyITriggerMoment_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TTriggerMoment >* pV = new std::vector<mvIMPACT::acquire::TTriggerMoment > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyITriggerMoment_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write((std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TTriggerMoment >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TTriggerMoment>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyITriggerMoment_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyITriggerMoment_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyITriggerMoment_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyITriggerMoment_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyITriggerMoment_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyITriggerMoment_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyITriggerMoment_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyITriggerMoment_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::write(mvIMPACT::acquire::TTriggerMoment,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::write(mvIMPACT::acquire::TTriggerMoment) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::write(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::write(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::write(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >::write(std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyITriggerMoment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyITriggerMoment" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyITriggerMoment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyITriggerMoment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTTriggerMoment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *)new std::pair< std::string,mvIMPACT::acquire::TTriggerMoment >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTTriggerMoment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TTriggerMoment arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTTriggerMoment" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTTriggerMoment" "', argument " "2"" of type '" "mvIMPACT::acquire::TTriggerMoment""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TTriggerMoment >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *)new std::pair< std::string,mvIMPACT::acquire::TTriggerMoment >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTTriggerMoment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *ptr = (std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTTriggerMoment" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTTriggerMoment" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *)new std::pair< std::string,mvIMPACT::acquire::TTriggerMoment >((std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTTriggerMoment(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTTriggerMoment", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTTriggerMoment__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTTriggerMoment__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTTriggerMoment__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTTriggerMoment'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TTriggerMoment >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TTriggerMoment >::pair(std::string,mvIMPACT::acquire::TTriggerMoment)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TTriggerMoment >::pair(std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTTriggerMoment_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTTriggerMoment_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTTriggerMoment_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTTriggerMoment_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTTriggerMoment_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTTriggerMoment_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTTriggerMoment_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTTriggerMoment_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  mvIMPACT::acquire::TTriggerMoment arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTTriggerMoment_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTTriggerMoment_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTTriggerMoment_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TTriggerMoment""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TTriggerMoment >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTTriggerMoment_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TTriggerMoment result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTTriggerMoment_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TTriggerMoment) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTTriggerMoment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTTriggerMoment" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTTriggerMoment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTTriggerMoment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIUserDataAccessRight__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIUserDataAccessRight__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIUserDataAccessRight" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIUserDataAccessRight__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIUserDataAccessRight" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIUserDataAccessRight" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIUserDataAccessRight(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIUserDataAccessRight", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIUserDataAccessRight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIUserDataAccessRight__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIUserDataAccessRight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIUserDataAccessRight'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIUserDataAccessRight_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TUserDataAccessRight> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TUserDataAccessRight> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TUserDataAccessRight> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TUserDataAccessRight>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TUserDataAccessRight>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataAccessRight_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIUserDataAccessRight_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIUserDataAccessRight_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TUserDataAccessRight result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataAccessRight_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TUserDataAccessRight result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIUserDataAccessRight_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIUserDataAccessRight_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIUserDataAccessRight_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIUserDataAccessRight_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TUserDataAccessRight result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TUserDataAccessRight result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TUserDataAccessRight result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TUserDataAccessRight result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TUserDataAccessRight result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataAccessRight_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIUserDataAccessRight_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIUserDataAccessRight_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIUserDataAccessRight_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::read(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::read(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::read(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::read(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::read(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::read(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  mvIMPACT::acquire::TUserDataAccessRight arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TUserDataAccessRight""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TUserDataAccessRight >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  mvIMPACT::acquire::TUserDataAccessRight arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TUserDataAccessRight""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TUserDataAccessRight >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataAccessRight >* pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataAccessRight_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataAccessRight >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataAccessRight>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIUserDataAccessRight_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIUserDataAccessRight_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIUserDataAccessRight_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIUserDataAccessRight_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIUserDataAccessRight_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::write(mvIMPACT::acquire::TUserDataAccessRight,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::write(mvIMPACT::acquire::TUserDataAccessRight) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::write(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::write(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::write(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >::write(std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIUserDataAccessRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIUserDataAccessRight" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIUserDataAccessRight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIUserDataAccessRight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTUserDataAccessRight__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *)new std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTUserDataAccessRight__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TUserDataAccessRight arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTUserDataAccessRight" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTUserDataAccessRight" "', argument " "2"" of type '" "mvIMPACT::acquire::TUserDataAccessRight""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TUserDataAccessRight >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *)new std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTUserDataAccessRight__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *ptr = (std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTUserDataAccessRight" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTUserDataAccessRight" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *)new std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight >((std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTUserDataAccessRight(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTUserDataAccessRight", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTUserDataAccessRight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTUserDataAccessRight__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTUserDataAccessRight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTUserDataAccessRight'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight >::pair(std::string,mvIMPACT::acquire::TUserDataAccessRight)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight >::pair(std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTUserDataAccessRight_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTUserDataAccessRight_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTUserDataAccessRight_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTUserDataAccessRight_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTUserDataAccessRight_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTUserDataAccessRight_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTUserDataAccessRight_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTUserDataAccessRight_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  mvIMPACT::acquire::TUserDataAccessRight arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTUserDataAccessRight_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTUserDataAccessRight_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTUserDataAccessRight_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TUserDataAccessRight""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TUserDataAccessRight >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTUserDataAccessRight_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TUserDataAccessRight result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTUserDataAccessRight_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TUserDataAccessRight) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTUserDataAccessRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTUserDataAccessRight" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTUserDataAccessRight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTUserDataAccessRight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIUserDataReconnectBehaviour__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIUserDataReconnectBehaviour__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIUserDataReconnectBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIUserDataReconnectBehaviour__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIUserDataReconnectBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIUserDataReconnectBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIUserDataReconnectBehaviour(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIUserDataReconnectBehaviour", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIUserDataReconnectBehaviour__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIUserDataReconnectBehaviour__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIUserDataReconnectBehaviour__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIUserDataReconnectBehaviour'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIUserDataReconnectBehaviour_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TUserDataReconnectBehaviour> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TUserDataReconnectBehaviour> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TUserDataReconnectBehaviour> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TUserDataReconnectBehaviour>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TUserDataReconnectBehaviour>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIUserDataReconnectBehaviour_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIUserDataReconnectBehaviour_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TUserDataReconnectBehaviour result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TUserDataReconnectBehaviour result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIUserDataReconnectBehaviour_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIUserDataReconnectBehaviour_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIUserDataReconnectBehaviour_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIUserDataReconnectBehaviour_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TUserDataReconnectBehaviour result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TUserDataReconnectBehaviour result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TUserDataReconnectBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TUserDataReconnectBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TUserDataReconnectBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataReconnectBehaviour_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIUserDataReconnectBehaviour_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIUserDataReconnectBehaviour_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::read(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::read(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::read(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::read(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::read(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::read(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  mvIMPACT::acquire::TUserDataReconnectBehaviour arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TUserDataReconnectBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TUserDataReconnectBehaviour >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  mvIMPACT::acquire::TUserDataReconnectBehaviour arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TUserDataReconnectBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TUserDataReconnectBehaviour >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >* pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIUserDataReconnectBehaviour_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TUserDataReconnectBehaviour>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIUserDataReconnectBehaviour_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIUserDataReconnectBehaviour_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::write(mvIMPACT::acquire::TUserDataReconnectBehaviour,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::write(mvIMPACT::acquire::TUserDataReconnectBehaviour) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::write(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::write(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::write(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >::write(std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIUserDataReconnectBehaviour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIUserDataReconnectBehaviour" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIUserDataReconnectBehaviour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIUserDataReconnectBehaviour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTUserDataReconnectBehaviour__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *)new std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTUserDataReconnectBehaviour__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TUserDataReconnectBehaviour arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTUserDataReconnectBehaviour" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTUserDataReconnectBehaviour" "', argument " "2"" of type '" "mvIMPACT::acquire::TUserDataReconnectBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TUserDataReconnectBehaviour >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *)new std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTUserDataReconnectBehaviour__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *ptr = (std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTUserDataReconnectBehaviour" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTUserDataReconnectBehaviour" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *)new std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour >((std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTUserDataReconnectBehaviour(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTUserDataReconnectBehaviour", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTUserDataReconnectBehaviour__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTUserDataReconnectBehaviour__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTUserDataReconnectBehaviour__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTUserDataReconnectBehaviour'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour >::pair(std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour >::pair(std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTUserDataReconnectBehaviour_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTUserDataReconnectBehaviour_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTUserDataReconnectBehaviour_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTUserDataReconnectBehaviour_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTUserDataReconnectBehaviour_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTUserDataReconnectBehaviour_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTUserDataReconnectBehaviour_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTUserDataReconnectBehaviour_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  mvIMPACT::acquire::TUserDataReconnectBehaviour arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTUserDataReconnectBehaviour_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTUserDataReconnectBehaviour_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTUserDataReconnectBehaviour_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TUserDataReconnectBehaviour""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TUserDataReconnectBehaviour >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTUserDataReconnectBehaviour_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TUserDataReconnectBehaviour result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTUserDataReconnectBehaviour_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TUserDataReconnectBehaviour) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTUserDataReconnectBehaviour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTUserDataReconnectBehaviour" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTUserDataReconnectBehaviour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTUserDataReconnectBehaviour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIVideoStandard__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIVideoStandard__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIVideoStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIVideoStandard__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIVideoStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIVideoStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIVideoStandard(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIVideoStandard", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyIVideoStandard__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyIVideoStandard__SWIG_2(self, argc, argv);} 
  check_2: if (argc == 1) { PyObject *retobj = _wrap_new_PropertyIVideoStandard__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIVideoStandard'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TVideoStandard >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIVideoStandard_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TVideoStandard> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TVideoStandard> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TVideoStandard> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TVideoStandard>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TVideoStandard>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVideoStandard_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVideoStandard_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIVideoStandard_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVideoStandard_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVideoStandard_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TVideoStandard result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVideoStandard_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TVideoStandard result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVideoStandard_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIVideoStandard_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVideoStandard_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVideoStandard_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIVideoStandard_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIVideoStandard_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TVideoStandard result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVideoStandard_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TVideoStandard result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVideoStandard result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVideoStandard result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVideoStandard result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ; int arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVideoStandard_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVideoStandard_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVideoStandard_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVideoStandard_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVideoStandard_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIVideoStandard_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVideoStandard_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVideoStandard_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVideoStandard_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVideoStandard_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIVideoStandard_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIVideoStandard_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVideoStandard_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIVideoStandard_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIVideoStandard_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIVideoStandard_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIVideoStandard_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIVideoStandard_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVideoStandard_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::read(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::read(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::read(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::read(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::read(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::read(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  mvIMPACT::acquire::TVideoStandard arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVideoStandard_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TVideoStandard""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVideoStandard >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVideoStandard_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  mvIMPACT::acquire::TVideoStandard arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVideoStandard_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TVideoStandard""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVideoStandard >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVideoStandard_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVideoStandard_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVideoStandard_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVideoStandard_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVideoStandard >* pV = new std::vector<mvIMPACT::acquire::TVideoStandard > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVideoStandard_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVideoStandard >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVideoStandard>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVideoStandard_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIVideoStandard_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVideoStandard_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIVideoStandard_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIVideoStandard_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIVideoStandard_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIVideoStandard_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVideoStandard_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::write(mvIMPACT::acquire::TVideoStandard,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::write(mvIMPACT::acquire::TVideoStandard) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::write(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::write(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::write(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >::write(std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIVideoStandard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIVideoStandard" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIVideoStandard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIVideoStandard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTVideoStandard__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *)new std::pair< std::string,mvIMPACT::acquire::TVideoStandard >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTVideoStandard__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TVideoStandard arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTVideoStandard" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTVideoStandard" "', argument " "2"" of type '" "mvIMPACT::acquire::TVideoStandard""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVideoStandard >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *)new std::pair< std::string,mvIMPACT::acquire::TVideoStandard >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTVideoStandard__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *ptr = (std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTVideoStandard" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVideoStandard > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTVideoStandard" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVideoStandard > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *)new std::pair< std::string,mvIMPACT::acquire::TVideoStandard >((std::pair< std::string,mvIMPACT::acquire::TVideoStandard > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTVideoStandard(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTVideoStandard", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTVideoStandard__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTVideoStandard__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTVideoStandard__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTVideoStandard'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TVideoStandard >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TVideoStandard >::pair(std::string,mvIMPACT::acquire::TVideoStandard)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TVideoStandard >::pair(std::pair< std::string,mvIMPACT::acquire::TVideoStandard > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTVideoStandard_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTVideoStandard_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVideoStandard_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTVideoStandard_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTVideoStandard_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTVideoStandard_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVideoStandard_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTVideoStandard_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *) 0 ;
  mvIMPACT::acquire::TVideoStandard arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTVideoStandard_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVideoStandard_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTVideoStandard_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TVideoStandard""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVideoStandard >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTVideoStandard_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVideoStandard result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVideoStandard_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TVideoStandard) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTVideoStandard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTVideoStandard" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTVideoStandard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTVideoStandard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIVirtualDeviceImageType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIVirtualDeviceImageType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIVirtualDeviceImageType" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIVirtualDeviceImageType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIVirtualDeviceImageType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIVirtualDeviceImageType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIVirtualDeviceImageType(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIVirtualDeviceImageType", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIVirtualDeviceImageType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIVirtualDeviceImageType__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIVirtualDeviceImageType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIVirtualDeviceImageType'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceImageType_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TVirtualDeviceImageType> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceImageType> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceImageType> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceImageType>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceImageType>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceImageType_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVirtualDeviceImageType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TVirtualDeviceImageType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TVirtualDeviceImageType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceImageType_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVirtualDeviceImageType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceImageType_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceImageType_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TVirtualDeviceImageType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TVirtualDeviceImageType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVirtualDeviceImageType result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVirtualDeviceImageType result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVirtualDeviceImageType result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceImageType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceImageType_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVirtualDeviceImageType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  mvIMPACT::acquire::TVirtualDeviceImageType arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TVirtualDeviceImageType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVirtualDeviceImageType >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  mvIMPACT::acquire::TVirtualDeviceImageType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TVirtualDeviceImageType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVirtualDeviceImageType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceImageType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceImageType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceImageType>( *i ) ) ) { SWIG_fail; }  }
     }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceImageType_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIVirtualDeviceImageType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIVirtualDeviceImageType_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceImageType_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVirtualDeviceImageType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::write(mvIMPACT::acquire::TVirtualDeviceImageType,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::write(mvIMPACT::acquire::TVirtualDeviceImageType) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::write(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::write(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::write(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >::write(std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIVirtualDeviceImageType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIVirtualDeviceImageType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIVirtualDeviceImageType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIVirtualDeviceImageType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTVirtualDeviceImageType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *)new std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTVirtualDeviceImageType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TVirtualDeviceImageType arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTVirtualDeviceImageType" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTVirtualDeviceImageType" "', argument " "2"" of type '" "mvIMPACT::acquire::TVirtualDeviceImageType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVirtualDeviceImageType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *)new std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTVirtualDeviceImageType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *ptr = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTVirtualDeviceImageType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTVirtualDeviceImageType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *)new std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType >((std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTVirtualDeviceImageType(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTVirtualDeviceImageType", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTVirtualDeviceImageType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTVirtualDeviceImageType__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTVirtualDeviceImageType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTVirtualDeviceImageType'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType >::pair(std::string,mvIMPACT::acquire::TVirtualDeviceImageType)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType >::pair(std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTVirtualDeviceImageType_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTVirtualDeviceImageType_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVirtualDeviceImageType_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTVirtualDeviceImageType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTVirtualDeviceImageType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTVirtualDeviceImageType_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVirtualDeviceImageType_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTVirtualDeviceImageType_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  mvIMPACT::acquire::TVirtualDeviceImageType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTVirtualDeviceImageType_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVirtualDeviceImageType_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTVirtualDeviceImageType_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TVirtualDeviceImageType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVirtualDeviceImageType >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTVirtualDeviceImageType_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVirtualDeviceImageType result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVirtualDeviceImageType_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TVirtualDeviceImageType) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTVirtualDeviceImageType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTVirtualDeviceImageType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTVirtualDeviceImageType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTVirtualDeviceImageType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIVirtualDeviceTestMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIVirtualDeviceTestMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIVirtualDeviceTestMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIVirtualDeviceTestMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIVirtualDeviceTestMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIVirtualDeviceTestMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIVirtualDeviceTestMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIVirtualDeviceTestMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIVirtualDeviceTestMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIVirtualDeviceTestMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIVirtualDeviceTestMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIVirtualDeviceTestMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceTestMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TVirtualDeviceTestMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceTestMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceTestMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceTestMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TVirtualDeviceTestMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceTestMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVirtualDeviceTestMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TVirtualDeviceTestMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TVirtualDeviceTestMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceTestMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVirtualDeviceTestMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceTestMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceTestMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TVirtualDeviceTestMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TVirtualDeviceTestMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVirtualDeviceTestMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVirtualDeviceTestMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVirtualDeviceTestMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceTestMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceTestMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVirtualDeviceTestMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::read(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  mvIMPACT::acquire::TVirtualDeviceTestMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TVirtualDeviceTestMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVirtualDeviceTestMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  mvIMPACT::acquire::TVirtualDeviceTestMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TVirtualDeviceTestMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVirtualDeviceTestMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >* pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIVirtualDeviceTestMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TVirtualDeviceTestMode>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIVirtualDeviceTestMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIVirtualDeviceTestMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::write(mvIMPACT::acquire::TVirtualDeviceTestMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::write(mvIMPACT::acquire::TVirtualDeviceTestMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::write(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::write(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::write(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >::write(std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIVirtualDeviceTestMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIVirtualDeviceTestMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIVirtualDeviceTestMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIVirtualDeviceTestMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTVirtualDeviceTestMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *)new std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTVirtualDeviceTestMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TVirtualDeviceTestMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTVirtualDeviceTestMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTVirtualDeviceTestMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TVirtualDeviceTestMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVirtualDeviceTestMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *)new std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTVirtualDeviceTestMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTVirtualDeviceTestMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTVirtualDeviceTestMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *)new std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode >((std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTVirtualDeviceTestMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTVirtualDeviceTestMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTVirtualDeviceTestMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTVirtualDeviceTestMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTVirtualDeviceTestMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTVirtualDeviceTestMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode >::pair(std::string,mvIMPACT::acquire::TVirtualDeviceTestMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode >::pair(std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTVirtualDeviceTestMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTVirtualDeviceTestMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVirtualDeviceTestMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTVirtualDeviceTestMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTVirtualDeviceTestMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTVirtualDeviceTestMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVirtualDeviceTestMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTVirtualDeviceTestMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  mvIMPACT::acquire::TVirtualDeviceTestMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTVirtualDeviceTestMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVirtualDeviceTestMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTVirtualDeviceTestMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TVirtualDeviceTestMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TVirtualDeviceTestMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTVirtualDeviceTestMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TVirtualDeviceTestMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTVirtualDeviceTestMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TVirtualDeviceTestMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTVirtualDeviceTestMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTVirtualDeviceTestMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTVirtualDeviceTestMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTVirtualDeviceTestMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIWhiteBalanceCalibrationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIWhiteBalanceCalibrationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIWhiteBalanceCalibrationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIWhiteBalanceCalibrationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIWhiteBalanceCalibrationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIWhiteBalanceCalibrationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIWhiteBalanceCalibrationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIWhiteBalanceCalibrationMode", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIWhiteBalanceCalibrationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIWhiteBalanceCalibrationMode__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIWhiteBalanceCalibrationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIWhiteBalanceCalibrationMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceCalibrationMode_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TWhiteBalanceCalibrationMode> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceCalibrationMode> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceCalibrationMode> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceCalibrationMode>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceCalibrationMode>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceCalibrationMode_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIWhiteBalanceCalibrationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TWhiteBalanceCalibrationMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TWhiteBalanceCalibrationMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceCalibrationMode_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::TWhiteBalanceCalibrationMode result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TWhiteBalanceCalibrationMode result;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TWhiteBalanceCalibrationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TWhiteBalanceCalibrationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TWhiteBalanceCalibrationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceCalibrationMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceCalibrationMode_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIWhiteBalanceCalibrationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  mvIMPACT::acquire::TWhiteBalanceCalibrationMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TWhiteBalanceCalibrationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  mvIMPACT::acquire::TWhiteBalanceCalibrationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TWhiteBalanceCalibrationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceCalibrationMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::const_iterator i = arg2->begin(); i != arg2->end(); ++i )
    { if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>( *i ) ) ) { SWIG_fail; }
       }  }  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceCalibrationMode_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIWhiteBalanceCalibrationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::write(mvIMPACT::acquire::TWhiteBalanceCalibrationMode,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::write(mvIMPACT::acquire::TWhiteBalanceCalibrationMode) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::write(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::write(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::write(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::write(std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIWhiteBalanceCalibrationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIWhiteBalanceCalibrationMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIWhiteBalanceCalibrationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIWhiteBalanceCalibrationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTWhiteBalanceCalibrationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *)new std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTWhiteBalanceCalibrationMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TWhiteBalanceCalibrationMode arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTWhiteBalanceCalibrationMode" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTWhiteBalanceCalibrationMode" "', argument " "2"" of type '" "mvIMPACT::acquire::TWhiteBalanceCalibrationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *)new std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTWhiteBalanceCalibrationMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *ptr = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTWhiteBalanceCalibrationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTWhiteBalanceCalibrationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *)new std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode >((std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTWhiteBalanceCalibrationMode(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTWhiteBalanceCalibrationMode", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTWhiteBalanceCalibrationMode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTWhiteBalanceCalibrationMode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTWhiteBalanceCalibrationMode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTWhiteBalanceCalibrationMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::pair(std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode >::pair(std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTWhiteBalanceCalibrationMode_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTWhiteBalanceCalibrationMode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTWhiteBalanceCalibrationMode_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTWhiteBalanceCalibrationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTWhiteBalanceCalibrationMode_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTWhiteBalanceCalibrationMode_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTWhiteBalanceCalibrationMode_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTWhiteBalanceCalibrationMode_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  mvIMPACT::acquire::TWhiteBalanceCalibrationMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTWhiteBalanceCalibrationMode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTWhiteBalanceCalibrationMode_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTWhiteBalanceCalibrationMode_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TWhiteBalanceCalibrationMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTWhiteBalanceCalibrationMode_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TWhiteBalanceCalibrationMode result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTWhiteBalanceCalibrationMode_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTWhiteBalanceCalibrationMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTWhiteBalanceCalibrationMode" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTWhiteBalanceCalibrationMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTWhiteBalanceCalibrationMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyIWhiteBalanceParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIWhiteBalanceParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyIWhiteBalanceParameter" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIWhiteBalanceParameter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyIWhiteBalanceParameter" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyIWhiteBalanceParameter" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIWhiteBalanceParameter(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyIWhiteBalanceParameter", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyIWhiteBalanceParameter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyIWhiteBalanceParameter__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyIWhiteBalanceParameter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyIWhiteBalanceParameter'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::EnumPropertyI()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::EnumPropertyI(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::EnumPropertyI(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceParameter_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TWhiteBalanceParameter> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceParameter> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceParameter> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceParameter>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TWhiteBalanceParameter>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceParameter_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIWhiteBalanceParameter_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TWhiteBalanceParameter result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TWhiteBalanceParameter result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceParameter_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIWhiteBalanceParameter_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceParameter_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceParameter_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TWhiteBalanceParameter result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TWhiteBalanceParameter result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TWhiteBalanceParameter result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TWhiteBalanceParameter result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TWhiteBalanceParameter result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceParameter_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceParameter_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIWhiteBalanceParameter_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::read(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  mvIMPACT::acquire::TWhiteBalanceParameter arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TWhiteBalanceParameter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TWhiteBalanceParameter >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  mvIMPACT::acquire::TWhiteBalanceParameter arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TWhiteBalanceParameter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TWhiteBalanceParameter >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >* pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIWhiteBalanceParameter_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TWhiteBalanceParameter >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TWhiteBalanceParameter>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyIWhiteBalanceParameter_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyIWhiteBalanceParameter_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIWhiteBalanceParameter_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyIWhiteBalanceParameter_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyIWhiteBalanceParameter_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::write(mvIMPACT::acquire::TWhiteBalanceParameter,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::write(mvIMPACT::acquire::TWhiteBalanceParameter) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::write(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::write(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::write(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >::write(std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyIWhiteBalanceParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIWhiteBalanceParameter" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIWhiteBalanceParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyIWhiteBalanceParameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTWhiteBalanceParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *)new std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTWhiteBalanceParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TWhiteBalanceParameter arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTWhiteBalanceParameter" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTWhiteBalanceParameter" "', argument " "2"" of type '" "mvIMPACT::acquire::TWhiteBalanceParameter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TWhiteBalanceParameter >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *)new std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTWhiteBalanceParameter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *ptr = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTWhiteBalanceParameter" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTWhiteBalanceParameter" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *)new std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter >((std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTWhiteBalanceParameter(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTWhiteBalanceParameter", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTWhiteBalanceParameter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTWhiteBalanceParameter__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTWhiteBalanceParameter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTWhiteBalanceParameter'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter >::pair(std::string,mvIMPACT::acquire::TWhiteBalanceParameter)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter >::pair(std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTWhiteBalanceParameter_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTWhiteBalanceParameter_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTWhiteBalanceParameter_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTWhiteBalanceParameter_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTWhiteBalanceParameter_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTWhiteBalanceParameter_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTWhiteBalanceParameter_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTWhiteBalanceParameter_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  mvIMPACT::acquire::TWhiteBalanceParameter arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTWhiteBalanceParameter_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTWhiteBalanceParameter_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTWhiteBalanceParameter_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TWhiteBalanceParameter""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TWhiteBalanceParameter >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTWhiteBalanceParameter_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TWhiteBalanceParameter result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTWhiteBalanceParameter_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TWhiteBalanceParameter) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTWhiteBalanceParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTWhiteBalanceParameter" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTWhiteBalanceParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTWhiteBalanceParameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyI64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyI64" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyI64" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyI64" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyI64", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyI64__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyI64__SWIG_2(self, argc, argv);}  check_2:
  if (argc == 1) { PyObject *retobj = _wrap_new_PropertyI64__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyI64'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::EnumPropertyI64()\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::EnumPropertyI64(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::EnumPropertyI64(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::int64_type >,std::allocator< std::pair< std::string,mvIMPACT::acquire::int64_type > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI64_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::int64_type> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::int64_type> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 ); {
    int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::int64_type> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::int64_type>* resultptr = new std::pair< std::string, mvIMPACT::acquire::int64_type>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_long_t, 1); if(!newItem)
      { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyI64_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::int64_type result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::int64_type)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::int64_type result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::int64_type)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyI64_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI64_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI64_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; }  { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::int64_type result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64_read" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::int64_type)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::int64_type result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::int64_type)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::int64_type result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::int64_type)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::int64_type result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::int64_type)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::int64_type result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::int64_type)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; int arg3 ; int arg4 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; }  { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ;
  int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64_read" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyI64_read" "', argument " "5"" of type '" "int""'"); }  
  arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64_read" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64_read" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyI64_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyI64_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI64_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyI64_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyI64_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyI64_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyI64_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::read(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::read(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::read(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::read(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::read(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::read(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64_write" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
    arg2 = static_cast< mvIMPACT::acquire::int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64_write" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
    arg2 = static_cast< mvIMPACT::acquire::int64_type >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; int arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write((std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; }  { try {
      { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write((std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; bool arg3 ;
  int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64_write" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64_write" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write((std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > *arg2 = 0 ; bool arg3 ;
  void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::int64_type >* pV = new std::vector<mvIMPACT::acquire::int64_type > (0); arg2 = pV; } 
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64_write" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write((std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::int64_type >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::int64_type>( *i ) ) ) { SWIG_fail; }  }  }  {
    delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyI64_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyI64_write__SWIG_5(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyI64_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyI64_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyI64_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::write(mvIMPACT::acquire::int64_type,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::write(mvIMPACT::acquire::int64_type) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::write(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::write(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::write(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >::write(std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyI64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyI64" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyI64_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyI64_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringint64_type__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::int64_type > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::int64_type > *)new std::pair< std::string,mvIMPACT::acquire::int64_type >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_long_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringint64_type__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::int64_type arg2 ; long val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::int64_type > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringint64_type" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringint64_type" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
    arg2 = static_cast< mvIMPACT::acquire::int64_type >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::int64_type > *)new std::pair< std::string,mvIMPACT::acquire::int64_type >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_long_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringint64_type__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::int64_type > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::int64_type > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::int64_type > *ptr = (std::pair< std::string,mvIMPACT::acquire::int64_type > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringint64_type" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::int64_type > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringint64_type" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::int64_type > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::int64_type > *)new std::pair< std::string,mvIMPACT::acquire::int64_type >((std::pair< std::string,mvIMPACT::acquire::int64_type > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_long_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringint64_type(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringint64_type", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringint64_type__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringint64_type__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringint64_type__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringint64_type'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::int64_type >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::int64_type >::pair(std::string,mvIMPACT::acquire::int64_type)\n"
  "    std::pair< std::string,mvIMPACT::acquire::int64_type >::pair(std::pair< std::string,mvIMPACT::acquire::int64_type > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringint64_type_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::int64_type > *arg1 = (std::pair< std::string,mvIMPACT::acquire::int64_type > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringint64_type_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_long_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringint64_type_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::int64_type > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::int64_type > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringint64_type_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringint64_type_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringint64_type_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::int64_type > *arg1 = (std::pair< std::string,mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_long_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringint64_type_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::int64_type > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::int64_type > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringint64_type_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::int64_type > *arg1 = (std::pair< std::string,mvIMPACT::acquire::int64_type > *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringint64_type_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_long_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringint64_type_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::int64_type > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::int64_type > * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringint64_type_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
    arg2 = static_cast< mvIMPACT::acquire::int64_type >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringint64_type_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::int64_type > *arg1 = (std::pair< std::string,mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::int64_type result; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_long_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringint64_type_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::int64_type > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::int64_type > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::int64_type) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringint64_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::int64_type > *arg1 = (std::pair< std::string,mvIMPACT::acquire::int64_type > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_long_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringint64_type" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::int64_type > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::int64_type > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringint64_type_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_long_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringint64_type_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyI64BufferPartDataType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64BufferPartDataType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyI64BufferPartDataType" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64BufferPartDataType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyI64BufferPartDataType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyI64BufferPartDataType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64BufferPartDataType(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyI64BufferPartDataType", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyI64BufferPartDataType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyI64BufferPartDataType__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyI64BufferPartDataType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyI64BufferPartDataType'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::EnumPropertyI64()\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::EnumPropertyI64(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::EnumPropertyI64(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI64BufferPartDataType_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TBufferPartDataType> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TBufferPartDataType> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TBufferPartDataType> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TBufferPartDataType>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TBufferPartDataType>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64BufferPartDataType_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64BufferPartDataType_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64BufferPartDataType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBufferPartDataType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64BufferPartDataType_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBufferPartDataType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64BufferPartDataType_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64BufferPartDataType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI64BufferPartDataType_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI64BufferPartDataType_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TBufferPartDataType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TBufferPartDataType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBufferPartDataType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBufferPartDataType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBufferPartDataType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64BufferPartDataType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64BufferPartDataType_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyI64BufferPartDataType_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64BufferPartDataType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::read(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::read(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::read(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::read(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::read(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::read(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  mvIMPACT::acquire::TBufferPartDataType arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBufferPartDataType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBufferPartDataType >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  mvIMPACT::acquire::TBufferPartDataType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TBufferPartDataType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBufferPartDataType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType >* pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64BufferPartDataType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TBufferPartDataType >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TBufferPartDataType>( *i ) ) ) { SWIG_fail; }  }  } 
  { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64BufferPartDataType_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyI64BufferPartDataType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyI64BufferPartDataType_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyI64BufferPartDataType_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64BufferPartDataType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::write(mvIMPACT::acquire::TBufferPartDataType,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::write(mvIMPACT::acquire::TBufferPartDataType) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::write(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::write(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::write(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >::write(std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyI64BufferPartDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyI64BufferPartDataType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyI64BufferPartDataType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyI64BufferPartDataType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTBufferPartDataType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *)new std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBufferPartDataType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TBufferPartDataType arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTBufferPartDataType" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTBufferPartDataType" "', argument " "2"" of type '" "mvIMPACT::acquire::TBufferPartDataType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBufferPartDataType >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *)new std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBufferPartDataType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *ptr = (std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTBufferPartDataType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTBufferPartDataType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *)new std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType >((std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTBufferPartDataType(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTBufferPartDataType", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTBufferPartDataType__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTBufferPartDataType__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTBufferPartDataType__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTBufferPartDataType'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType >::pair(std::string,mvIMPACT::acquire::TBufferPartDataType)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType >::pair(std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTBufferPartDataType_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBufferPartDataType_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBufferPartDataType_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTBufferPartDataType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTBufferPartDataType_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBufferPartDataType_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBufferPartDataType_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBufferPartDataType_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  mvIMPACT::acquire::TBufferPartDataType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTBufferPartDataType_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBufferPartDataType_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTBufferPartDataType_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TBufferPartDataType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TBufferPartDataType >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTBufferPartDataType_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TBufferPartDataType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTBufferPartDataType_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TBufferPartDataType) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTBufferPartDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTBufferPartDataType" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTBufferPartDataType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTBufferPartDataType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyI64DeviceTriggerOverlap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64DeviceTriggerOverlap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyI64DeviceTriggerOverlap" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64DeviceTriggerOverlap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyI64DeviceTriggerOverlap" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyI64DeviceTriggerOverlap" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64DeviceTriggerOverlap(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyI64DeviceTriggerOverlap", 0, 1, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_PropertyI64DeviceTriggerOverlap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2;
    return _wrap_new_PropertyI64DeviceTriggerOverlap__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_PropertyI64DeviceTriggerOverlap__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyI64DeviceTriggerOverlap'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::EnumPropertyI64()\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::EnumPropertyI64(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::EnumPropertyI64(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI64DeviceTriggerOverlap_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, mvIMPACT::acquire::TDeviceTriggerOverlap> >* pV = new std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerOverlap> > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerOverlap> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i)
    {
      std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerOverlap>* resultptr = new std::pair< std::string, mvIMPACT::acquire::TDeviceTriggerOverlap>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64DeviceTriggerOverlap_getTranslationDictString", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64DeviceTriggerOverlap_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::getTranslationDictString() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceTriggerOverlap result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceTriggerOverlap result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64DeviceTriggerOverlap_getTranslationDictValue", 0, 2, argv))) SWIG_fail;
  --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64DeviceTriggerOverlap_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::getTranslationDictValue() const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI64DeviceTriggerOverlap_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyI64DeviceTriggerOverlap_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceTriggerOverlap result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceTriggerOverlap result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerOverlap result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerOverlap result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerOverlap result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64DeviceTriggerOverlap_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64DeviceTriggerOverlap_read", 0, 5, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2;
    return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64DeviceTriggerOverlap_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::read(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  mvIMPACT::acquire::TDeviceTriggerOverlap arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerOverlap""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerOverlap >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  mvIMPACT::acquire::TDeviceTriggerOverlap arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerOverlap""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerOverlap >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > *arg2 = 0 ;
  bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    if( !PyList_Check(swig_obj[1]) ) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >* pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap > (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyI64DeviceTriggerOverlap_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<mvIMPACT::acquire::TDeviceTriggerOverlap>( *i ) ) ) { SWIG_fail; }  }  }
   { delete( arg2 ); }  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyI64DeviceTriggerOverlap_write", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1;
    return _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_5(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyI64DeviceTriggerOverlap_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::write(mvIMPACT::acquire::TDeviceTriggerOverlap,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::write(mvIMPACT::acquire::TDeviceTriggerOverlap) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >::write(std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyI64DeviceTriggerOverlap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyI64DeviceTriggerOverlap" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyI64DeviceTriggerOverlap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyI64DeviceTriggerOverlap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerOverlap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerOverlap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; mvIMPACT::acquire::TDeviceTriggerOverlap arg2 ; int val2 ; int ecode2 = 0 ;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringTDeviceTriggerOverlap" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringTDeviceTriggerOverlap" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerOverlap""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerOverlap >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerOverlap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ; std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *ptr = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringTDeviceTriggerOverlap" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringTDeviceTriggerOverlap" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *)new std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap >((std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringTDeviceTriggerOverlap(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringTDeviceTriggerOverlap", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 0) { PyObject *retobj = _wrap_new_pairstringTDeviceTriggerOverlap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringTDeviceTriggerOverlap__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringTDeviceTriggerOverlap__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringTDeviceTriggerOverlap'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap >::pair()\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap >::pair(std::string,mvIMPACT::acquire::TDeviceTriggerOverlap)\n"
  "    std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap >::pair(std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerOverlap_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceTriggerOverlap_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerOverlap_first_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    std::string *ptr = (std::string *)0; res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringTDeviceTriggerOverlap_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringTDeviceTriggerOverlap_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerOverlap_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerOverlap_first_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerOverlap_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  mvIMPACT::acquire::TDeviceTriggerOverlap arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringTDeviceTriggerOverlap_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerOverlap_second_set" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringTDeviceTriggerOverlap_second_set" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceTriggerOverlap""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceTriggerOverlap >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->second = arg2; SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_pairstringTDeviceTriggerOverlap_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceTriggerOverlap result;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringTDeviceTriggerOverlap_second_get" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::TDeviceTriggerOverlap) ((arg1)->second);
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail:
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringTDeviceTriggerOverlap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *arg1 = (std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringTDeviceTriggerOverlap" "', argument " "1"" of type '" "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringTDeviceTriggerOverlap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringTDeviceTriggerOverlap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PropertyF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *)new mvIMPACT::acquire::EnumPropertyF< double >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PropertyF" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *)new mvIMPACT::acquire::EnumPropertyF< double >(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyF__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropertyF" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropertyF" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *)new mvIMPACT::acquire::EnumPropertyF< double >((mvIMPACT::acquire::EnumPropertyF< double > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyF(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PropertyF", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_PropertyF__SWIG_0(self, argc, argv); if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_2; return _wrap_new_PropertyF__SWIG_2(self, argc, argv);}  check_2:
  if (argc == 1) { PyObject *retobj = _wrap_new_PropertyF__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PropertyF'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyF< double >::EnumPropertyF()\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::EnumPropertyF(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::EnumPropertyF(mvIMPACT::acquire::EnumPropertyF< double > const &)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyF_getTranslationDict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if (!PyList_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::pair<std::string, double> >* pV = new std::vector<std::pair< std::string, double> > (0); arg2 = pV; }  {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDict(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); {
    int lsize = PySequence_Length( swig_obj[1] ); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for(std::vector<std::pair< std::string, double> >::const_iterator i = arg2->begin(); i != arg2->end(); ++i) {
      std::pair< std::string, double>* resultptr = new std::pair< std::string, double>(*i);
      PyObject* newItem = SWIG_NewPointerObj( (void *)( resultptr ), SWIGTYPE_p_std__pairT_std__string_double_t, 1);
      if(!newItem) { SWIG_fail; }  if( -1 == PyList_Append( swig_obj[1], newItem ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; std::string result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyF_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictString(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; std::string result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictString();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictString(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyF_getTranslationDictString", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyF_getTranslationDictString__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyF_getTranslationDictString__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyF_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyF< double >::getTranslationDictString(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::getTranslationDictString() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyF_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictValue(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; double result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyF_getTranslationDictValue", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_PropertyF_getTranslationDictValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_PropertyF_getTranslationDictValue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyF_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyF< double >::getTranslationDictValue(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::getTranslationDictValue() const\n"); return 0; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyF_getTranslationDictStrings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<std::string >* pV = new std::vector<std::string > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictStrings(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<std::string >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], PyString_FromString( (*i).c_str() ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "PropertyF_getTranslationDictValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictValues(*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; double result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyF_read" "', argument " "2"" of type '" "int""'"); }  
  arg2 = static_cast< int >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(arg2); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; double result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; double result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getMaxValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; double result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getMinValue();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; double result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getStepWidth();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; int arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyF_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyF_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyF_read" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ;
  bool val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyF_read" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyF_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PropertyF_read" "', argument " "5"" of type '" "int""'"); }  
  arg5 = static_cast< int >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3,arg4,arg5); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyF_read" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyF_read" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyF_read" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void(); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyF_read", 0, 5, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_PropertyF_read__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_2; return _wrap_PropertyF_read__SWIG_4(self, argc, argv);}
   check_2: if (argc == 2) { PyObject *retobj = _wrap_PropertyF_read__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyF_read__SWIG_7(self, argc, argv);}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyF_read__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    PyObject *retobj = _wrap_PropertyF_read__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_6: if (argc == 4) {
    PyObject *retobj = _wrap_PropertyF_read__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 5) {
    PyObject *retobj = _wrap_PropertyF_read__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyF_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyF< double >::read(int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::read() const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::read(std::vector< double,std::allocator< double > > &,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::read(std::vector< double,std::allocator< double > > &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::read(std::vector< double,std::allocator< double > > &) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::read(std::vector< double,std::allocator< double > > &,bool,int,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::read(std::vector< double,std::allocator< double > > &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::read(std::vector< double,std::allocator< double > > &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  double arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ;
  mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyF_write" "', argument " "2"" of type '" "double""'"); }  
  arg2 = static_cast< double >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyF_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  double arg2 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyF_write" "', argument " "2"" of type '" "double""'"); }  
  arg2 = static_cast< double >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyF_write" "', argument " "3"" of type '" "int""'"); }  
  arg3 = static_cast< int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write((std::vector< double,std::allocator< double > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write((std::vector< double,std::allocator< double > > const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyF_write" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PropertyF_write" "', argument " "4"" of type '" "int""'"); }  
  arg4 = static_cast< int >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write((std::vector< double,std::allocator< double > > const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyF_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<double >* pV = new std::vector<double > (0); arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyF_write" "', argument " "3"" of type '" "bool""'"); }  
  arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write((std::vector< double,std::allocator< double > > const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); {
    int lsize = PySequence_Length(swig_obj[1]); if( -1 == PySequence_DelSlice( swig_obj[1], 0, lsize ) ) { SWIG_fail; } 
    for( std::vector<double >::const_iterator i = arg2->begin(); i != arg2->end(); ++i ) {
      if( -1 == PyList_Append( swig_obj[1], CToPyObject<double>( *i ) ) ) { SWIG_fail; }  }  }  { delete( arg2 ); } 
  return resultobj; fail: { delete( arg2 ); }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "PropertyF_write", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_1; return _wrap_PropertyF_write__SWIG_3(self, argc, argv);}
   check_1: if (argc == 2) { PyObject *retobj = _wrap_PropertyF_write__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { {
        _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyF_write__SWIG_5(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PyList_Check(argv[1]) ? 1 : 0;  } }  if (!_v) goto check_4;
    PyObject *retobj = _wrap_PropertyF_write__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_4: if (argc == 3) {
    PyObject *retobj = _wrap_PropertyF_write__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) {
    PyObject *retobj = _wrap_PropertyF_write__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PropertyF_write'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyF< double >::write(double,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::write(double) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::write(std::vector< double,std::allocator< double > > const &,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::write(std::vector< double,std::allocator< double > > const &) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::write(std::vector< double,std::allocator< double > > const &,bool,int) const\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >::write(std::vector< double,std::allocator< double > > const &,bool) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_PropertyF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyF" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyF< double > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyF< double > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PropertyF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairstringdouble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,double > *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (std::pair< std::string,double > *)new std::pair< std::string,double >();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringdouble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::string arg1 ; double arg2 ; double val2 ; int ecode2 = 0 ;
  std::pair< std::string,double > *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    std::string *ptr = (std::string *)0; int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_pairstringdouble" "', argument " "1"" of type '" "std::string""'");  }
     arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; }  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pairstringdouble" "', argument " "2"" of type '" "double""'"); }
    arg2 = static_cast< double >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,double > *)new std::pair< std::string,double >(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringdouble__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; std::pair< std::string,double > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ;
  std::pair< std::string,double > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    std::pair< std::string,double > *ptr = (std::pair< std::string,double > *)0; res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairstringdouble" "', argument " "1"" of type '" "std::pair< std::string,double > const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairstringdouble" "', argument " "1"" of type '" "std::pair< std::string,double > const &""'"); }
     arg1 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (std::pair< std::string,double > *)new std::pair< std::string,double >((std::pair< std::string,double > const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; }
SWIGINTERN PyObject *_wrap_new_pairstringdouble(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairstringdouble", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_pairstringdouble__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairstringdouble__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairstringdouble__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairstringdouble'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,double >::pair()\n"
  "    std::pair< std::string,double >::pair(std::string,double)\n"
  "    std::pair< std::string,double >::pair(std::pair< std::string,double > const &)\n"); return 0; }
SWIGINTERN PyObject *_wrap_pairstringdouble_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,double > *arg1 = (std::pair< std::string,double > *) 0 ; std::string *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; int res2 = SWIG_OLDOBJ ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringdouble_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_double_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringdouble_first_set" "', argument " "1"" of type '" "std::pair< std::string,double > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,double > * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairstringdouble_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pairstringdouble_first_set" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->first = *arg2; SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail:
  if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_pairstringdouble_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,double > *arg1 = (std::pair< std::string,double > *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; std::string *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_double_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringdouble_first_get" "', argument " "1"" of type '" "std::pair< std::string,double > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,double > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->first); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringdouble_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; std::pair< std::string,double > *arg1 = (std::pair< std::string,double > *) 0 ; double arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; PyObject *swig_obj[2] ;
  if (!SWIG_Python_UnpackTuple(args, "pairstringdouble_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_double_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringdouble_second_set" "', argument " "1"" of type '" "std::pair< std::string,double > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,double > * >(argp1); ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairstringdouble_second_set" "', argument " "2"" of type '" "double""'"); }
    arg2 = static_cast< double >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; if (arg1) (arg1)->second = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_pairstringdouble_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; std::pair< std::string,double > *arg1 = (std::pair< std::string,double > *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; double result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_double_t, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairstringdouble_second_get" "', argument " "1"" of type '" "std::pair< std::string,double > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,double > * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (double) ((arg1)->second); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_pairstringdouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  std::pair< std::string,double > *arg1 = (std::pair< std::string,double > *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__string_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairstringdouble" "', argument " "1"" of type '" "std::pair< std::string,double > *""'");  }
   arg1 = reinterpret_cast< std::pair< std::string,double > * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *pairstringdouble_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_std__string_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairstringdouble_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DeviceControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::DeviceControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeviceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DeviceControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeviceControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DeviceControl *)new mvIMPACT::acquire::GenICam::DeviceControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::DeviceControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeviceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DeviceControl *)new mvIMPACT::acquire::GenICam::DeviceControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DeviceControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_DeviceControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_DeviceControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DeviceControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::DeviceControl::DeviceControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::DeviceControl::DeviceControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceScanType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceScanType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceScanType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceVendorName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceVendorName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceVendorName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceModelName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceModelName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceModelName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceFamilyName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceFamilyName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceFamilyName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceManufacturerInfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceManufacturerInfo_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceManufacturerInfo); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceFirmwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceFirmwareVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceFirmwareVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceFirmwareBuildDate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceFirmwareBuildDate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvDeviceFirmwareBuildDate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceSerialNumber_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceSerialNumber_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceSerialNumber); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceUserID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceUserID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceUserID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceSFNCVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceSFNCVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceSFNCVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceSFNCVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceSFNCVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceSFNCVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceSFNCVersionSubMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceSFNCVersionSubMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceSFNCVersionSubMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceManifestEntrySelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceManifestEntrySelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceManifestEntrySelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceManifestXMLMajorVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceManifestXMLMajorVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceManifestXMLMajorVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceManifestXMLMinorVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceManifestXMLMinorVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceManifestXMLMinorVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceManifestXMLSubMinorVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceManifestXMLSubMinorVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceManifestXMLSubMinorVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceManifestSchemaMajorVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceManifestSchemaMajorVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceManifestSchemaMajorVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceManifestSchemaMinorVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceManifestSchemaMinorVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceManifestSchemaMinorVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceManifestPrimaryURL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceManifestPrimaryURL_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceManifestPrimaryURL); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceManifestSecondaryURL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceManifestSecondaryURL_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceManifestSecondaryURL); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceTLType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceTLType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceTLType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceTLVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceTLVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceTLVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceTLVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceTLVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceTLVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceTLVersionSubMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceTLVersionSubMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceTLVersionSubMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceGenCPVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceGenCPVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceGenCPVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceGenCPVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceGenCPVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceGenCPVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceMaxThroughput_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceMaxThroughput_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceMaxThroughput); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceConnectionSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceConnectionSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceConnectionSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceConnectionSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceConnectionSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceConnectionSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceConnectionStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceConnectionStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceConnectionStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceLinkSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceLinkSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceLinkSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceLinkSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceLinkSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceLinkSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceLinkThroughputLimitMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceLinkThroughputLimitMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceLinkThroughputLimitMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceLinkThroughputLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceLinkThroughputLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceLinkThroughputLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceLinkConnectionCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceLinkConnectionCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceLinkConnectionCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceLinkHeartbeatMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceLinkHeartbeatMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceLinkHeartbeatMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceLinkHeartbeatTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceLinkHeartbeatTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->deviceLinkHeartbeatTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceLinkCommandTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceLinkCommandTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->deviceLinkCommandTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceStreamChannelCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceStreamChannelCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceStreamChannelCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceStreamChannelSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceStreamChannelSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceStreamChannelSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceStreamChannelType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceStreamChannelType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceStreamChannelType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceStreamChannelLink_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceStreamChannelLink_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceStreamChannelLink); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceStreamChannelEndianness_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceStreamChannelEndianness_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceStreamChannelEndianness); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceStreamChannelPacketSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceStreamChannelPacketSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceStreamChannelPacketSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceEventChannelCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceEventChannelCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceEventChannelCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceMessageChannelCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceMessageChannelCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceMessageChannelCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceCharacterSet_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceCharacterSet_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceCharacterSet); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->deviceReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceIndicatorMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceIndicatorMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceIndicatorMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceFeaturePersistenceStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceFeaturePersistenceStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->deviceFeaturePersistenceStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceFeaturePersistenceEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceFeaturePersistenceEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->deviceFeaturePersistenceEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceRegistersStreamingStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceRegistersStreamingStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->deviceRegistersStreamingStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceRegistersStreamingEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceRegistersStreamingEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->deviceRegistersStreamingEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceRegistersCheck_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceRegistersCheck_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->deviceRegistersCheck); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceRegistersValid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceRegistersValid_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->deviceRegistersValid); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceRegistersStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceRegistersStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceRegistersStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceRegistersEndianness_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceRegistersEndianness_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceRegistersEndianness); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceTemperatureSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceTemperatureSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceTemperatureSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceTemperature_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceTemperature_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->deviceTemperature); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceClockSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceClockSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceClockSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceClockFrequency_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceClockFrequency_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->deviceClockFrequency); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceSerialPortSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceSerialPortSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceSerialPortSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_deviceSerialPortBaudRate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_deviceSerialPortBaudRate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceSerialPortBaudRate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_timestampReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_timestampReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->timestampReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_timestampLatch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_timestampLatch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->timestampLatch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_timestampLatchValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_timestampLatchValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->timestampLatchValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_rcSystemReady_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_rcSystemReady_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->rcSystemReady); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceTemperatureRaw_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceTemperatureRaw_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceTemperatureRaw); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceTemperatureUpperLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceTemperatureUpperLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvDeviceTemperatureUpperLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceTemperatureLowerLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceTemperatureLowerLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvDeviceTemperatureLowerLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceTemperatureLimitHysteresis_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceTemperatureLimitHysteresis_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceTemperatureLimitHysteresis); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceClockFrequency_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceClockFrequency_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceClockFrequency); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceSensorColorMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceSensorColorMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceSensorColorMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceFPGAVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceFPGAVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvDeviceFPGAVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceFirmwareSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceFirmwareSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceFirmwareSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceProcessingUnitSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceProcessingUnitSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceProcessingUnitSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceProcessingUnit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceProcessingUnit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceProcessingUnit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceStatusLEDEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceStatusLEDEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvDeviceStatusLEDEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDevicePowerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDevicePowerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDevicePowerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceStandbyTimeoutEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceStandbyTimeoutEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvDeviceStandbyTimeoutEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceStandbyTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceStandbyTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceStandbyTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceFirmwareHashCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceFirmwareHashCode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvDeviceFirmwareHashCode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvCalculateHashCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvCalculateHashCode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvCalculateHashCode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceFirmwareHashAlgorithm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceFirmwareHashAlgorithm_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceFirmwareHashAlgorithm); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceLaserCurrent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceLaserCurrent_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceLaserCurrent); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvTimestampPPSSync_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvTimestampPPSSync_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTimestampPPSSync); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvTimestampPPSTriggerEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvTimestampPPSTriggerEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTimestampPPSTriggerEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvTimestampPPSPulsesMissed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvTimestampPPSPulsesMissed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTimestampPPSPulsesMissed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvTimestampPPSStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvTimestampPPSStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTimestampPPSStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvTimestampResetValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvTimestampResetValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTimestampResetValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceTimeSync_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceTimeSync_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceTimeSync); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvDeviceTimeSyncPushValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvDeviceTimeSyncPushValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceTimeSyncPushValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvTemperatureState_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvTemperatureState_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTemperatureState); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceControl_mvTemperatureStateCriticalThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceControl_mvTemperatureStateCriticalThreshold_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTemperatureStateCriticalThreshold); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_DeviceControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DeviceControl *arg1 = (mvIMPACT::acquire::GenICam::DeviceControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeviceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *DeviceControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DeviceControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ImageFormatControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::ImageFormatControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFormatControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ImageFormatControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFormatControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::ImageFormatControl *)new mvIMPACT::acquire::GenICam::ImageFormatControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageFormatControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::ImageFormatControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFormatControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::ImageFormatControl *)new mvIMPACT::acquire::GenICam::ImageFormatControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ImageFormatControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ImageFormatControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_ImageFormatControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ImageFormatControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ImageFormatControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::ImageFormatControl::ImageFormatControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::ImageFormatControl::ImageFormatControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_sensorWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_sensorWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sensorWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_sensorHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_sensorHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sensorHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_sensorPixelWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_sensorPixelWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->sensorPixelWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_sensorPixelHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_sensorPixelHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->sensorPixelHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_sensorName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_sensorName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->sensorName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_sensorShutterMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_sensorShutterMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sensorShutterMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_sensorTaps_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_sensorTaps_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sensorTaps); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_sensorDigitizationTaps_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_sensorDigitizationTaps_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sensorDigitizationTaps); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_widthMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_widthMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->widthMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_heightMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_heightMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->heightMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_regionSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_regionSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->regionSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_regionMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_regionMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->regionMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_regionDestination_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_regionDestination_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->regionDestination); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_regionIDValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_regionIDValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->regionIDValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_componentSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_componentSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->componentSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_componentEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_componentEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->componentEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_componentIDValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_componentIDValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->componentIDValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_groupSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_groupSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->groupSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_groupIDValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_groupIDValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->groupIDValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_imageComponentSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_imageComponentSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->imageComponentSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_imageComponentEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_imageComponentEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->imageComponentEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_width_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->width); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_height_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->height); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_offsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_offsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->offsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_offsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_offsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->offsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvBlockscanLinesPerBlock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvBlockscanLinesPerBlock_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvBlockscanLinesPerBlock); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvBlockscanBlockCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvBlockscanBlockCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvBlockscanBlockCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvMultiAreaMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvMultiAreaMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvMultiAreaMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvAreaSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvAreaSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAreaSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvAreaEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvAreaEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvAreaEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvAreaWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvAreaWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAreaWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvAreaHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvAreaHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAreaHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvAreaOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvAreaOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAreaOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvAreaOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvAreaOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAreaOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvAreaResultingOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvAreaResultingOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAreaResultingOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvAreaResultingOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvAreaResultingOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAreaResultingOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_linePitchEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_linePitchEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->linePitchEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_linePitch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_linePitch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->linePitch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_binningSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_binningSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->binningSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_binningHorizontalMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_binningHorizontalMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->binningHorizontalMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_binningHorizontal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_binningHorizontal_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->binningHorizontal); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_binningVerticalMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_binningVerticalMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->binningVerticalMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_binningVertical_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_binningVertical_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->binningVertical); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_decimationHorizontalMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_decimationHorizontalMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->decimationHorizontalMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_decimationHorizontal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_decimationHorizontal_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->decimationHorizontal); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_decimationVerticalMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_decimationVerticalMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->decimationVerticalMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_decimationVertical_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_decimationVertical_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->decimationVertical); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_reverseX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_reverseX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->reverseX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_reverseY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_reverseY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->reverseY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_pixelFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_pixelFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->pixelFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_pixelFormatInfoSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_pixelFormatInfoSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->pixelFormatInfoSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_pixelFormatInfoID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_pixelFormatInfoID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->pixelFormatInfoID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_pixelCoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_pixelCoding_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->pixelCoding); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_pixelSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_pixelSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->pixelSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_pixelColorFilter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_pixelColorFilter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->pixelColorFilter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_pixelDynamicRangeMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_pixelDynamicRangeMin_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->pixelDynamicRangeMin); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_pixelDynamicRangeMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_pixelDynamicRangeMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->pixelDynamicRangeMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_testPatternGeneratorSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_testPatternGeneratorSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->testPatternGeneratorSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_testPattern_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_testPattern_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->testPattern); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_testImageSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_testImageSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->testImageSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_deinterlacing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_deinterlacing_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deinterlacing); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_imageCompressionMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_imageCompressionMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->imageCompressionMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_imageCompressionRateOption_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_imageCompressionRateOption_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->imageCompressionRateOption); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_imageCompressionQuality_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_imageCompressionQuality_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->imageCompressionQuality); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_imageCompressionBitrate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_imageCompressionBitrate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->imageCompressionBitrate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_imageCompressionJPEGFormatOption_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_imageCompressionJPEGFormatOption_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->imageCompressionJPEGFormatOption); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvSensorDigitizationBitDepth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvSensorDigitizationBitDepth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSensorDigitizationBitDepth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvDualAdcMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvDualAdcMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvDualAdcMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImageFormatControl_mvDualAdcCompression_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageFormatControl_mvDualAdcCompression_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDualAdcCompression); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ImageFormatControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ImageFormatControl *arg1 = (mvIMPACT::acquire::GenICam::ImageFormatControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageFormatControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ImageFormatControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ImageFormatControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ImageFormatControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__ImageFormatControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImageFormatControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AcquisitionControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::AcquisitionControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AcquisitionControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AcquisitionControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AcquisitionControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::AcquisitionControl *)new mvIMPACT::acquire::GenICam::AcquisitionControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_AcquisitionControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::AcquisitionControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AcquisitionControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::AcquisitionControl *)new mvIMPACT::acquire::GenICam::AcquisitionControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_AcquisitionControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AcquisitionControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_AcquisitionControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_AcquisitionControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AcquisitionControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::AcquisitionControl::AcquisitionControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::AcquisitionControl::AcquisitionControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->acquisitionMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->acquisitionStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionStop_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionStop_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->acquisitionStop); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionStopMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionStopMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->acquisitionStopMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionAbort_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionAbort_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->acquisitionAbort); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionArm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionArm_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->acquisitionArm); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->acquisitionFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionBurstFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionBurstFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->acquisitionBurstFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvSensorRegister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvSensorRegister_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSensorRegister); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvSensorRegisterValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvSensorRegisterValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSensorRegisterValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionFrameRate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionFrameRate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->acquisitionFrameRate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionFrameRateEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionFrameRateEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->acquisitionFrameRateEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionLineRate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionLineRate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->acquisitionLineRate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionLineRateEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionLineRateEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->acquisitionLineRateEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionStatusSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionStatusSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->acquisitionStatusSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->acquisitionStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_triggerSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_triggerSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_triggerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_triggerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_triggerSoftware_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_triggerSoftware_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->triggerSoftware); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_triggerSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_triggerSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_triggerActivation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_triggerActivation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerActivation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_triggerOverlap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_triggerOverlap_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerOverlap); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_triggerDelay_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_triggerDelay_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->triggerDelay); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_triggerDivider_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_triggerDivider_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerDivider); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_triggerMultiplier_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_triggerMultiplier_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->triggerMultiplier); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->exposureMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureTimeMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureTimeMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->exposureTimeMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureTimeSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureTimeSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->exposureTimeSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureTime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureTime_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->exposureTime); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureHorizontalZoneDivider_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureHorizontalZoneDivider_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvExposureHorizontalZoneDivider); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureAuto_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureAuto_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->exposureAuto); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_multiSlopeMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_multiSlopeMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->multiSlopeMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_multiSlopeKneePointCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_multiSlopeKneePointCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->multiSlopeKneePointCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_multiSlopeKneePointSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_multiSlopeKneePointSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->multiSlopeKneePointSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_multiSlopeExposureLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_multiSlopeExposureLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->multiSlopeExposureLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_multiSlopeSaturationThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_multiSlopeSaturationThreshold_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->multiSlopeSaturationThreshold); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_multiSlopeIntensityLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_multiSlopeIntensityLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->multiSlopeIntensityLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_multiSlopeExposureGradient_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_multiSlopeExposureGradient_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->multiSlopeExposureGradient); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureTimeAutoMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureTimeAutoMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->exposureTimeAutoMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureRegionOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureRegionOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->exposureRegionOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureRegionOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureRegionOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->exposureRegionOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureRegionWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureRegionWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->exposureRegionWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_exposureRegionHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_exposureRegionHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->exposureRegionHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionAlternateFilter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionAlternateFilter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->acquisitionAlternateFilter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_acquisitionMultiPartMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_acquisitionMultiPartMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->acquisitionMultiPartMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_rcExposureAutoAverageMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_rcExposureAutoAverageMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->rcExposureAutoAverageMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_rcExposureAutoAverageMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_rcExposureAutoAverageMin_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->rcExposureAutoAverageMin); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvAcquisitionFrameRateLimitMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvAcquisitionFrameRateLimitMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAcquisitionFrameRateLimitMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvAcquisitionFrameRateEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvAcquisitionFrameRateEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAcquisitionFrameRateEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvResultingFrameRate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvResultingFrameRate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvResultingFrameRate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvShutterMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvShutterMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvShutterMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvCompressionKneepoint_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvCompressionKneepoint_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvCompressionKneepoint); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoLowerLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoLowerLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvExposureAutoLowerLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoUpperLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoUpperLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvExposureAutoUpperLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoDelayImages_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoDelayImages_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoDelayImages); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoAverageGrey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoAverageGrey_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoAverageGrey); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoHighlightAOI_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoHighlightAOI_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoHighlightAOI); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoAOIMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoAOIMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoAOIMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureAutoMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureAutoMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureAutoMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvSmearReduction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvSmearReduction_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSmearReduction); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureActiveShiftEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureActiveShiftEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvExposureActiveShiftEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvExposureActiveShift_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvExposureActiveShift_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvExposureActiveShift); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvAcquisitionMemoryMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvAcquisitionMemoryMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAcquisitionMemoryMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvPretriggerFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvPretriggerFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvPretriggerFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvAcquisitionMemoryMaxFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvAcquisitionMemoryMaxFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAcquisitionMemoryMaxFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvAcquisitionMemoryFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvAcquisitionMemoryFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAcquisitionMemoryFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvAcquisitionMemoryAOIParameterChanged_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvAcquisitionMemoryAOIParameterChanged_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAcquisitionMemoryAOIParameterChanged);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvFeatureMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvFeatureMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvFeatureMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvSmartFrameRecallEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvSmartFrameRecallEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvSmartFrameRecallEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvSmartFrameRecallTimestampLookupAccuracy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvSmartFrameRecallTimestampLookupAccuracy_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSmartFrameRecallTimestampLookupAccuracy);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvSmartFrameRecallFrameSkipRatio_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvSmartFrameRecallFrameSkipRatio_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSmartFrameRecallFrameSkipRatio); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AcquisitionControl_mvLensCalibrationEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcquisitionControl_mvLensCalibrationEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvLensCalibrationEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_AcquisitionControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AcquisitionControl *arg1 = (mvIMPACT::acquire::GenICam::AcquisitionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcquisitionControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AcquisitionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AcquisitionControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *AcquisitionControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AcquisitionControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalogControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::AnalogControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalogControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalogControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalogControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::AnalogControl *)new mvIMPACT::acquire::GenICam::AnalogControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_AnalogControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::AnalogControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalogControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::AnalogControl *)new mvIMPACT::acquire::GenICam::AnalogControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_AnalogControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalogControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_AnalogControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_AnalogControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalogControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::AnalogControl::AnalogControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::AnalogControl::AnalogControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvTapBalancingMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvTapBalancingMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTapBalancingMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_gainSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_gainSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gainSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_gain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_gain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainHorizontalZoneDivider_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainHorizontalZoneDivider_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvGainHorizontalZoneDivider); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_gainAuto_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_gainAuto_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gainAuto); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_gainAutoBalance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_gainAutoBalance_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gainAutoBalance); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_blackLevelSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_blackLevelSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->blackLevelSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_blackLevel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_blackLevel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->blackLevel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_blackLevelAuto_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_blackLevelAuto_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->blackLevelAuto); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_blackLevelAutoBalance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_blackLevelAutoBalance_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->blackLevelAutoBalance); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_whiteClipSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_whiteClipSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->whiteClipSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_whiteClip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_whiteClip_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->whiteClip); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_balanceRatioSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_balanceRatioSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->balanceRatioSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_balanceRatio_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_balanceRatio_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->balanceRatio); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_balanceWhiteAuto_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_balanceWhiteAuto_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->balanceWhiteAuto); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoDelayImages_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoDelayImages_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoDelayImages); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoUpperLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoUpperLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvGainAutoUpperLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoLowerLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoLowerLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvGainAutoLowerLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoAverageGrey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoAverageGrey_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoAverageGrey); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoHighlightAOI_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoHighlightAOI_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoHighlightAOI); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoAOIMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoAOIMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoAOIMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGainAutoMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGainAutoMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGainAutoMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvBalanceWhiteAutoAOIMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvBalanceWhiteAutoAOIMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvBalanceWhiteAutoAOIMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvBalanceWhiteAutoOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvBalanceWhiteAutoOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvBalanceWhiteAutoOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvBalanceWhiteAutoOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvBalanceWhiteAutoOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvBalanceWhiteAutoOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvBalanceWhiteAutoWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvBalanceWhiteAutoWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvBalanceWhiteAutoWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvBalanceWhiteAutoHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvBalanceWhiteAutoHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvBalanceWhiteAutoHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvLowLight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvLowLight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLowLight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvADCGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvADCGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvADCGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvVRamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvVRamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvVRamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvLinearLogarithmicMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvLinearLogarithmicMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLinearLogarithmicMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvDigitalGainOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvDigitalGainOffset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDigitalGainOffset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvSaveCalibrationData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvSaveCalibrationData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvSaveCalibrationData); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGammaEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGammaEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvGammaEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_mvGammaSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_mvGammaSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGammaSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_AnalogControl_gamma_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalogControl_gamma_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->gamma); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_AnalogControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::AnalogControl *arg1 = (mvIMPACT::acquire::GenICam::AnalogControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalogControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::AnalogControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::AnalogControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *AnalogControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalogControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LUTControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::LUTControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LUTControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LUTControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LUTControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::LUTControl *)new mvIMPACT::acquire::GenICam::LUTControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_LUTControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::LUTControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LUTControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::LUTControl *)new mvIMPACT::acquire::GenICam::LUTControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_LUTControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LUTControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_LUTControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_LUTControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LUTControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::LUTControl::LUTControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::LUTControl::LUTControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_LUTControl_LUTSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LUTControl *arg1 = (mvIMPACT::acquire::GenICam::LUTControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTControl_LUTSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LUTControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LUTControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->LUTSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTControl_LUTEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LUTControl *arg1 = (mvIMPACT::acquire::GenICam::LUTControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTControl_LUTEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LUTControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LUTControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->LUTEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTControl_LUTIndex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LUTControl *arg1 = (mvIMPACT::acquire::GenICam::LUTControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTControl_LUTIndex_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LUTControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LUTControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->LUTIndex); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTControl_LUTValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LUTControl *arg1 = (mvIMPACT::acquire::GenICam::LUTControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTControl_LUTValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LUTControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LUTControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->LUTValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTControl_LUTValueAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LUTControl *arg1 = (mvIMPACT::acquire::GenICam::LUTControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTControl_LUTValueAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LUTControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LUTControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->LUTValueAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTControl_mvLUTType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LUTControl *arg1 = (mvIMPACT::acquire::GenICam::LUTControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTControl_mvLUTType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LUTControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LUTControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLUTType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTControl_mvLUTInputData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LUTControl *arg1 = (mvIMPACT::acquire::GenICam::LUTControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTControl_mvLUTInputData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LUTControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LUTControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLUTInputData); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LUTControl_mvLUTMapping_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LUTControl *arg1 = (mvIMPACT::acquire::GenICam::LUTControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUTControl_mvLUTMapping_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LUTControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LUTControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLUTMapping); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_LUTControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LUTControl *arg1 = (mvIMPACT::acquire::GenICam::LUTControl *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LUTControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LUTControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LUTControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *LUTControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__LUTControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LUTControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ColorTransformationControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::ColorTransformationControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColorTransformationControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ColorTransformationControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColorTransformationControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::ColorTransformationControl *)new mvIMPACT::acquire::GenICam::ColorTransformationControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ColorTransformationControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::ColorTransformationControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColorTransformationControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::ColorTransformationControl *)new mvIMPACT::acquire::GenICam::ColorTransformationControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ColorTransformationControl(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ColorTransformationControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_ColorTransformationControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ColorTransformationControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ColorTransformationControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::ColorTransformationControl::ColorTransformationControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::ColorTransformationControl::ColorTransformationControl(mvIMPACT::acquire::Device *)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_ColorTransformationControl_colorTransformationSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ColorTransformationControl *arg1 = (mvIMPACT::acquire::GenICam::ColorTransformationControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTransformationControl_colorTransformationSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ColorTransformationControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ColorTransformationControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->colorTransformationSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ColorTransformationControl_colorTransformationEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ColorTransformationControl *arg1 = (mvIMPACT::acquire::GenICam::ColorTransformationControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTransformationControl_colorTransformationEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ColorTransformationControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ColorTransformationControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->colorTransformationEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ColorTransformationControl_colorTransformationValueSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ColorTransformationControl *arg1 = (mvIMPACT::acquire::GenICam::ColorTransformationControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTransformationControl_colorTransformationValueSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ColorTransformationControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ColorTransformationControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->colorTransformationValueSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ColorTransformationControl_colorTransformationValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ColorTransformationControl *arg1 = (mvIMPACT::acquire::GenICam::ColorTransformationControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTransformationControl_colorTransformationValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ColorTransformationControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ColorTransformationControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->colorTransformationValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ColorTransformationControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ColorTransformationControl *arg1 = (mvIMPACT::acquire::GenICam::ColorTransformationControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColorTransformationControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ColorTransformationControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ColorTransformationControl * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ColorTransformationControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ColorTransformationControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DigitalIOControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::DigitalIOControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DigitalIOControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DigitalIOControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DigitalIOControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DigitalIOControl *)new mvIMPACT::acquire::GenICam::DigitalIOControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_DigitalIOControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::DigitalIOControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DigitalIOControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DigitalIOControl *)new mvIMPACT::acquire::GenICam::DigitalIOControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DigitalIOControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DigitalIOControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_DigitalIOControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_DigitalIOControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DigitalIOControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::DigitalIOControl::DigitalIOControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::DigitalIOControl::DigitalIOControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_lineSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_lineSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->lineSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_lineMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_lineMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->lineMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_lineInverter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_lineInverter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->lineInverter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_lineStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_lineStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->lineStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_lineStatusAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_lineStatusAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->lineStatusAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_lineSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_lineSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->lineSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_lineFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_lineFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->lineFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_userOutputSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_userOutputSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->userOutputSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_userOutputValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_userOutputValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->userOutputValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_userOutputValueAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_userOutputValueAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->userOutputValueAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_userOutputValueAllMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_userOutputValueAllMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->userOutputValueAllMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_mvLineDebounceTimeRisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_mvLineDebounceTimeRisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLineDebounceTimeRisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_mvLineDebounceTimeFallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_mvLineDebounceTimeFallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLineDebounceTimeFallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_mvRTMInputSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_mvRTMInputSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvRTMInputSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_mvRTMSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_mvRTMSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvRTMSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_mvLineLED_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_mvLineLED_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLineLED); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalIOControl_mvEnable12VPowerOut_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DigitalIOControl_mvEnable12VPowerOut_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvEnable12VPowerOut); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_DigitalIOControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DigitalIOControl *arg1 = (mvIMPACT::acquire::GenICam::DigitalIOControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DigitalIOControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DigitalIOControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DigitalIOControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *DigitalIOControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__DigitalIOControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DigitalIOControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CounterAndTimerControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::CounterAndTimerControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CounterAndTimerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CounterAndTimerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CounterAndTimerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *)new mvIMPACT::acquire::GenICam::CounterAndTimerControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_CounterAndTimerControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CounterAndTimerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *)new mvIMPACT::acquire::GenICam::CounterAndTimerControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CounterAndTimerControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_CounterAndTimerControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_CounterAndTimerControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_CounterAndTimerControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CounterAndTimerControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::CounterAndTimerControl::CounterAndTimerControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::CounterAndTimerControl::CounterAndTimerControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterEventSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterEventSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterEventSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterEventActivation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterEventActivation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterEventActivation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterResetSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterResetSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterResetSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterResetActivation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterResetActivation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterResetActivation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->counterReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterValueAtReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterValueAtReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterValueAtReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterDuration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterDuration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterDuration); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterTriggerSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterTriggerSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterTriggerSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_counterTriggerActivation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_counterTriggerActivation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->counterTriggerActivation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_timerSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_timerSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->timerSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_timerDuration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_timerDuration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->timerDuration); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_timerDelay_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_timerDelay_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->timerDelay); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_timerReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_timerReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->timerReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_timerValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_timerValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->timerValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_timerStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_timerStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->timerStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_timerTriggerSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_timerTriggerSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->timerTriggerSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_timerTriggerActivation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_timerTriggerActivation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->timerTriggerActivation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CounterAndTimerControl_timerTriggerArmDelay_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterAndTimerControl_timerTriggerArmDelay_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->timerTriggerArmDelay); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CounterAndTimerControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CounterAndTimerControl *arg1 = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CounterAndTimerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CounterAndTimerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CounterAndTimerControl * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CounterAndTimerControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CounterAndTimerControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EncoderControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::EncoderControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncoderControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EncoderControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncoderControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::EncoderControl *)new mvIMPACT::acquire::GenICam::EncoderControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EncoderControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::EncoderControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncoderControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::EncoderControl *)new mvIMPACT::acquire::GenICam::EncoderControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_EncoderControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EncoderControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_EncoderControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_EncoderControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EncoderControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::EncoderControl::EncoderControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::EncoderControl::EncoderControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderSourceA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderSourceA_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderSourceA); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderSourceB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderSourceB_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderSourceB); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderDivider_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderDivider_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderDivider); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderOutputMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderOutputMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderOutputMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->encoderTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderResetSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderResetSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderResetSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderResetActivation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderResetActivation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderResetActivation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->encoderReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderValueAtReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderValueAtReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->encoderValueAtReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EncoderControl_encoderResolution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderControl_encoderResolution_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->encoderResolution); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_EncoderControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::EncoderControl *arg1 = (mvIMPACT::acquire::GenICam::EncoderControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncoderControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EncoderControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EncoderControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EncoderControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__EncoderControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EncoderControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogicBlockControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::LogicBlockControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogicBlockControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogicBlockControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogicBlockControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::LogicBlockControl *)new mvIMPACT::acquire::GenICam::LogicBlockControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_LogicBlockControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::LogicBlockControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogicBlockControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::LogicBlockControl *)new mvIMPACT::acquire::GenICam::LogicBlockControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_LogicBlockControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LogicBlockControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_LogicBlockControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_LogicBlockControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LogicBlockControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::LogicBlockControl::LogicBlockControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::LogicBlockControl::LogicBlockControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->logicBlockSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockFunction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockFunction_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->logicBlockFunction); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockInputNumber_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockInputNumber_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->logicBlockInputNumber); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockInputSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockInputSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->logicBlockInputSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockInputSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockInputSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->logicBlockInputSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockInputInverter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockInputInverter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->logicBlockInputInverter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockLUTIndex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockLUTIndex_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->logicBlockLUTIndex); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockLUTValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockLUTValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->logicBlockLUTValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockLUTValueAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockLUTValueAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->logicBlockLUTValueAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LogicBlockControl_logicBlockLUTSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogicBlockControl_logicBlockLUTSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->logicBlockLUTSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_LogicBlockControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LogicBlockControl *arg1 = (mvIMPACT::acquire::GenICam::LogicBlockControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogicBlockControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LogicBlockControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LogicBlockControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *LogicBlockControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__LogicBlockControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogicBlockControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoftwareSignalControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::SoftwareSignalControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoftwareSignalControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoftwareSignalControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SoftwareSignalControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SoftwareSignalControl *)new mvIMPACT::acquire::GenICam::SoftwareSignalControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SoftwareSignalControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_SoftwareSignalControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::SoftwareSignalControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoftwareSignalControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SoftwareSignalControl *)new mvIMPACT::acquire::GenICam::SoftwareSignalControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SoftwareSignalControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_SoftwareSignalControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoftwareSignalControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_SoftwareSignalControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_SoftwareSignalControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoftwareSignalControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::SoftwareSignalControl::SoftwareSignalControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::SoftwareSignalControl::SoftwareSignalControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_SoftwareSignalControl_softwareSignalSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SoftwareSignalControl *arg1 = (mvIMPACT::acquire::GenICam::SoftwareSignalControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SoftwareSignalControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoftwareSignalControl_softwareSignalSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SoftwareSignalControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SoftwareSignalControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->softwareSignalSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SoftwareSignalControl_softwareSignalPulse_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SoftwareSignalControl *arg1 = (mvIMPACT::acquire::GenICam::SoftwareSignalControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SoftwareSignalControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoftwareSignalControl_softwareSignalPulse_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SoftwareSignalControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SoftwareSignalControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->softwareSignalPulse); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SoftwareSignalControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SoftwareSignalControl *arg1 = (mvIMPACT::acquire::GenICam::SoftwareSignalControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SoftwareSignalControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoftwareSignalControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SoftwareSignalControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SoftwareSignalControl * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SoftwareSignalControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__SoftwareSignalControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoftwareSignalControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ActionControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::ActionControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ActionControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ActionControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ActionControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::ActionControl *)new mvIMPACT::acquire::GenICam::ActionControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ActionControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::ActionControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ActionControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::ActionControl *)new mvIMPACT::acquire::GenICam::ActionControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ActionControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ActionControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_ActionControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ActionControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ActionControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::ActionControl::ActionControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::ActionControl::ActionControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_ActionControl_actionUnconditionalMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::ActionControl *arg1 = (mvIMPACT::acquire::GenICam::ActionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionControl_actionUnconditionalMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ActionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ActionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionUnconditionalMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ActionControl_actionDeviceKey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::ActionControl *arg1 = (mvIMPACT::acquire::GenICam::ActionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionControl_actionDeviceKey_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ActionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ActionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionDeviceKey); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ActionControl_actionQueueSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::ActionControl *arg1 = (mvIMPACT::acquire::GenICam::ActionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionControl_actionQueueSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ActionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ActionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionQueueSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ActionControl_actionSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::ActionControl *arg1 = (mvIMPACT::acquire::GenICam::ActionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionControl_actionSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ActionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ActionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ActionControl_actionGroupMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::ActionControl *arg1 = (mvIMPACT::acquire::GenICam::ActionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionControl_actionGroupMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ActionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ActionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionGroupMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ActionControl_actionGroupKey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::ActionControl *arg1 = (mvIMPACT::acquire::GenICam::ActionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionControl_actionGroupKey_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ActionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ActionControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionGroupKey); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ActionControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ActionControl *arg1 = (mvIMPACT::acquire::GenICam::ActionControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ActionControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ActionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ActionControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ActionControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ActionControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EventControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::EventControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EventControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EventControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::EventControl *)new mvIMPACT::acquire::GenICam::EventControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_EventControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::EventControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::EventControl *)new mvIMPACT::acquire::GenICam::EventControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_EventControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EventControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_EventControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_EventControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EventControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::EventControl::EventControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::EventControl::EventControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_EventControl_eventSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventNotification_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventNotification_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventNotification); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTrigger_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTrigger_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTrigger); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTriggerTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTriggerTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTriggerTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTriggerFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTriggerFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTriggerFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTriggerMissed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTriggerMissed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTriggerMissed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTriggerMissedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTriggerMissedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTriggerMissedTimestamp);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTriggerMissedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTriggerMissedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTriggerMissedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionStartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionStartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionStartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionStartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionStartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionStartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionEndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionEndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionEndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionEndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionEndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionEndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTransferStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTransferStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTransferStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTransferStartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTransferStartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTransferStartTimestamp);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTransferStartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTransferStartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTransferStartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTransferEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTransferEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTransferEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTransferEndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTransferEndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTransferEndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionTransferEndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionTransferEndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionTransferEndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionError_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionError_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionError); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionErrorTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionErrorTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionErrorTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventAcquisitionErrorFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventAcquisitionErrorFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventAcquisitionErrorFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameBurstStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameBurstStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameBurstStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameBurstStartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameBurstStartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameBurstStartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameBurstStartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameBurstStartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameBurstStartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameBurstEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameBurstEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameBurstEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameBurstEndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameBurstEndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameBurstEndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameBurstEndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameBurstEndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameBurstEndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTrigger_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTrigger_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTrigger); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTriggerTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTriggerTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTriggerTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTriggerFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTriggerFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTriggerFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTriggerMissed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTriggerMissed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTriggerMissed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTriggerMissedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTriggerMissedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTriggerMissedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTriggerMissedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTriggerMissedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTriggerMissedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventDeviceTemperatureStateNormal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventDeviceTemperatureStateNormal_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventDeviceTemperatureStateNormal); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventDeviceTemperatureStateNormalTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventDeviceTemperatureStateNormalTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventDeviceTemperatureStateNormalTimestamp);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventDeviceTemperatureStateCritical_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventDeviceTemperatureStateCritical_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventDeviceTemperatureStateCritical); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventDeviceTemperatureStateCriticalTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventDeviceTemperatureStateCriticalTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventDeviceTemperatureStateCriticalTimestamp);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventDeviceTemperatureStateOverTemperature_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventDeviceTemperatureStateOverTemperature_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventDeviceTemperatureStateOverTemperature);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventDeviceTemperatureStateOverTemperatureTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventDeviceTemperatureStateOverTemperatureTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventDeviceTemperatureStateOverTemperatureTimestamp);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameStartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameStartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameStartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameStartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameStartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameStartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameEndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameEndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameEndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameEndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameEndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameEndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTransferStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTransferStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTransferStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTransferStartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTransferStartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTransferStartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTransferStartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTransferStartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTransferStartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTransferEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTransferEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTransferEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTransferEndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTransferEndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTransferEndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventFrameTransferEndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventFrameTransferEndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventFrameTransferEndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineTrigger_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineTrigger_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineTrigger); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineTriggerTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineTriggerTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineTriggerTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineTriggerFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineTriggerFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineTriggerFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineTriggerMissed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineTriggerMissed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineTriggerMissed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineTriggerMissedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineTriggerMissedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineTriggerMissedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineTriggerMissedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineTriggerMissedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineTriggerMissedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineStartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineStartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineStartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineStartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineStartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineStartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineEndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineEndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineEndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLineEndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLineEndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLineEndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventExposureStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventExposureStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventExposureStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventExposureStartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventExposureStartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventExposureStartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventExposureStartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventExposureStartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventExposureStartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventExposureEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventExposureEnd_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventExposureEnd); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventExposureEndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventExposureEndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventExposureEndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventExposureEndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventExposureEndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventExposureEndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventActionLate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventActionLate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventActionLate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventActionLateTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventActionLateTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventActionLateTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventActionLateFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventActionLateFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventActionLateFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventPrimaryApplicationSwitch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventPrimaryApplicationSwitch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventPrimaryApplicationSwitch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventPrimaryApplicationSwitchTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventPrimaryApplicationSwitchTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventPrimaryApplicationSwitchTimestamp);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventPrimaryApplicationSwitchFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventPrimaryApplicationSwitchFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventPrimaryApplicationSwitchFrameID); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTest_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTest_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTest); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTestTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTestTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTestTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter0Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter0Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter0Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter0StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter0StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter0StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter0StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter0StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter0StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter1Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter1Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter1Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter1StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter1StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter1StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter1StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter1StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter1StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter2Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter2Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter2Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter2StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter2StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter2StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter2StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter2StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter2StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter3Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter3Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter3Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter3StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter3StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter3StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter3StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter3StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter3StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter4Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter4Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter4Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter4StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter4StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter4StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter4StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter4StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter4StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter5Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter5Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter5Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter5StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter5StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter5StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter5StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter5StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter5StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter6Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter6Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter6Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter6StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter6StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter6StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter6StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter6StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter6StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter7Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter7Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter7Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter7StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter7StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter7StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter7StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter7StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter7StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter8Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter8Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter8Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter8StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter8StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter8StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter8StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter8StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter8StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter9Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter9Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter9Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter9StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter9StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter9StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter9StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter9StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter9StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter10Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter10Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter10Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter10StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter10StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter10StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter10StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter10StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter10StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter11Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter11Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter11Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter11StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter11StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter11StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter11StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter11StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter11StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter12Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter12Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter12Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter12StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter12StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter12StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter12StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter12StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter12StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter13Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter13Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter13Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter13StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter13StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter13StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter13StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter13StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter13StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter14Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter14Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter14Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter14StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter14StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter14StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter14StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter14StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter14StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter0End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter0End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter0End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter0EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter0EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter0EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter0EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter0EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter0EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter1End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter1End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter1End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter1EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter1EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter1EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter1EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter1EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter1EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter2End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter2End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter2End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter2EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter2EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter2EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter2EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter2EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter2EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter3End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter3End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter3End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter3EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter3EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter3EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter3EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter3EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter3EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter4End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter4End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter4End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter4EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter4EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter4EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter4EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter4EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter4EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter5End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter5End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter5End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter5EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter5EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter5EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter5EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter5EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter5EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter6End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter6End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter6End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter6EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter6EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter6EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter6EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter6EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter6EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter7End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter7End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter7End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter7EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter7EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter7EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter7EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter7EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter7EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter8End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter8End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter8End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter8EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter8EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter8EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter8EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter8EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter8EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter9End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter9End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter9End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter9EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter9EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter9EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter9EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter9EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter9EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter10End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter10End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter10End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter10EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter10EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter10EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter10EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter10EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter10EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter11End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter11End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter11End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter11EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter11EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter11EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter11EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter11EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter11EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter12End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter12End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter12End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter12EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter12EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter12EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter12EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter12EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter12EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter13End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter13End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter13End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter13EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter13EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter13EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter13EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter13EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter13EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter14End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter14End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter14End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter14EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter14EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter14EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventCounter14EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventCounter14EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventCounter14EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer0Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer0Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer0Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer0StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer0StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer0StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer0StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer0StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer0StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer1Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer1Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer1Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer1StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer1StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer1StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer1StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer1StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer1StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer2Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer2Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer2Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer2StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer2StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer2StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer2StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer2StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer2StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer3Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer3Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer3Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer3StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer3StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer3StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer3StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer3StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer3StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer4Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer4Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer4Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer4StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer4StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer4StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer4StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer4StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer4StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer5Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer5Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer5Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer5StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer5StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer5StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer5StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer5StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer5StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer6Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer6Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer6Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer6StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer6StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer6StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer6StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer6StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer6StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer7Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer7Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer7Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer7StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer7StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer7StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer7StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer7StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer7StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer8Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer8Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer8Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer8StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer8StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer8StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer8StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer8StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer8StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer9Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer9Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer9Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer9StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer9StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer9StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer9StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer9StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer9StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer10Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer10Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer10Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer10StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer10StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer10StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer10StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer10StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer10StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer11Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer11Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer11Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer11StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer11StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer11StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer11StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer11StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer11StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer12Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer12Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer12Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer12StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer12StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer12StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer12StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer12StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer12StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer13Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer13Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer13Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer13StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer13StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer13StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer13StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer13StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer13StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer14Start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer14Start_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer14Start); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer14StartTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer14StartTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer14StartTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer14StartFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer14StartFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer14StartFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer0End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer0End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer0End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer0EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer0EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer0EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer0EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer0EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer0EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer1End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer1End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer1End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer1EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer1EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer1EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer1EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer1EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer1EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer2End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer2End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer2End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer2EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer2EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer2EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer2EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer2EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer2EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer3End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer3End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer3End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer3EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer3EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer3EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer3EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer3EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer3EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer4End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer4End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer4End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer4EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer4EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer4EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer4EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer4EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer4EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer5End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer5End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer5End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer5EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer5EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer5EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer5EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer5EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer5EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer6End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer6End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer6End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer6EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer6EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer6EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer6EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer6EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer6EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer7End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer7End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer7End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer7EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer7EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer7EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer7EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer7EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer7EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer8End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer8End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer8End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer8EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer8EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer8EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer8EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer8EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer8EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer9End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer9End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer9End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer9EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer9EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer9EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer9EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer9EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer9EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer10End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer10End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer10End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer10EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer10EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer10EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer10EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer10EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer10EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer11End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer11End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer11End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer11EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer11EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer11EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer11EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer11EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer11EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer12End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer12End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer12End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer12EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer12EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer12EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer12EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer12EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer12EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer13End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer13End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer13End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer13EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer13EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer13EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer13EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer13EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer13EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer14End_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer14End_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer14End); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer14EndTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer14EndTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer14EndTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventTimer14EndFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventTimer14EndFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventTimer14EndFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder0Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder0Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder0Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder0StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder0StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder0StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder0StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder0StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder0StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder1Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder1Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder1Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder1StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder1StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder1StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder1StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder1StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder1StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder2Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder2Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder2Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder2StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder2StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder2StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder2StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder2StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder2StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder3Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder3Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder3Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder3StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder3StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder3StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder3StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder3StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder3StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder4Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder4Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder4Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder4StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder4StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder4StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder4StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder4StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder4StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder5Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder5Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder5Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder5StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder5StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder5StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder5StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder5StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder5StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder6Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder6Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder6Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder6StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder6StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder6StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder6StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder6StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder6StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder7Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder7Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder7Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder7StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder7StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder7StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder7StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder7StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder7StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder8Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder8Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder8Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder8StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder8StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder8StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder8StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder8StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder8StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder9Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder9Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder9Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder9StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder9StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder9StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder9StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder9StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder9StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder10Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder10Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder10Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder10StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder10StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder10StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder10StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder10StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder10StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder11Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder11Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder11Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder11StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder11StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder11StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder11StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder11StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder11StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder12Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder12Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder12Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder12StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder12StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder12StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder12StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder12StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder12StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder13Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder13Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder13Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder13StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder13StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder13StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder13StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder13StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder13StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder14Stopped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder14Stopped_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder14Stopped); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder14StoppedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder14StoppedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder14StoppedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder14StoppedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder14StoppedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder14StoppedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder0Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder0Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder0Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder0RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder0RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder0RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder0RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder0RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder0RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder1Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder1Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder1Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder1RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder1RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder1RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder1RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder1RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder1RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder2Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder2Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder2Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder2RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder2RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder2RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder2RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder2RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder2RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder3Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder3Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder3Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder3RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder3RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder3RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder3RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder3RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder3RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder4Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder4Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder4Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder4RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder4RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder4RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder4RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder4RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder4RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder5Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder5Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder5Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder5RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder5RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder5RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder5RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder5RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder5RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder6Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder6Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder6Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder6RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder6RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder6RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder6RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder6RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder6RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder7Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder7Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder7Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder7RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder7RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder7RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder7RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder7RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder7RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder8Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder8Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder8Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder8RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder8RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder8RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder8RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder8RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder8RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder9Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder9Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder9Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder9RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder9RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder9RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder9RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder9RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder9RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder10Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder10Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder10Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder10RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder10RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder10RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder10RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder10RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder10RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder11Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder11Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder11Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder11RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder11RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder11RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder11RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder11RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder11RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder12Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder12Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder12Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder12RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder12RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder12RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder12RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder12RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder12RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder13Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder13Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder13Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder13RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder13RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder13RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder13RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder13RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder13RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder14Restarted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder14Restarted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder14Restarted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder14RestartedTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder14RestartedTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder14RestartedTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventEncoder14RestartedFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventEncoder14RestartedFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventEncoder14RestartedFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine0RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine0RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine0RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine0RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine0RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine0RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine0RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine0RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine0RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine1RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine1RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine1RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine1RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine1RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine1RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine1RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine1RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine1RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine2RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine2RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine2RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine2RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine2RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine2RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine2RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine2RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine2RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine3RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine3RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine3RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine3RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine3RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine3RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine3RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine3RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine3RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine4RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine4RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine4RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine4RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine4RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine4RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine4RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine4RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine4RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine5RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine5RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine5RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine5RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine5RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine5RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine5RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine5RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine5RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine6RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine6RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine6RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine6RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine6RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine6RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine6RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine6RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine6RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine7RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine7RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine7RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine7RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine7RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine7RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine7RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine7RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine7RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine8RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine8RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine8RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine8RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine8RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine8RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine8RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine8RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine8RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine9RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine9RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine9RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine9RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine9RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine9RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine9RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine9RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine9RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine10RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine10RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine10RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine10RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine10RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine10RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine10RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine10RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine10RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine11RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine11RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine11RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine11RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine11RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine11RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine11RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine11RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine11RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine12RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine12RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine12RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine12RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine12RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine12RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine12RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine12RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine12RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine13RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine13RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine13RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine13RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine13RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine13RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine13RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine13RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine13RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine14RisingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine14RisingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine14RisingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine14RisingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine14RisingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine14RisingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine14RisingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine14RisingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine14RisingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine0FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine0FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine0FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine0FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine0FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine0FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine0FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine0FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine0FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine1FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine1FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine1FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine1FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine1FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine1FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine1FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine1FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine1FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine2FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine2FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine2FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine2FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine2FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine2FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine2FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine2FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine2FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine3FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine3FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine3FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine3FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine3FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine3FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine3FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine3FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine3FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine4FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine4FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine4FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine4FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine4FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine4FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine4FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine4FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine4FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine5FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine5FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine5FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine5FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine5FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine5FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine5FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine5FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine5FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine6FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine6FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine6FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine6FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine6FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine6FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine6FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine6FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine6FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine7FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine7FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine7FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine7FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine7FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine7FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine7FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine7FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine7FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine8FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine8FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine8FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine8FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine8FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine8FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine8FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine8FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine8FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine9FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine9FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine9FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine9FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine9FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine9FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine9FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine9FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine9FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine10FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine10FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine10FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine10FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine10FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine10FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine10FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine10FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine10FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine11FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine11FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine11FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine11FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine11FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine11FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine11FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine11FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine11FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine12FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine12FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine12FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine12FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine12FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine12FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine12FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine12FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine12FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine13FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine13FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine13FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine13FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine13FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine13FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine13FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine13FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine13FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine14FallingEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine14FallingEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine14FallingEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine14FallingEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine14FallingEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine14FallingEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine14FallingEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine14FallingEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine14FallingEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine0AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine0AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine0AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine0AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine0AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine0AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine0AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine0AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine0AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine1AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine1AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine1AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine1AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine1AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine1AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine1AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine1AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine1AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine2AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine2AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine2AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine2AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine2AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine2AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine2AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine2AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine2AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine3AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine3AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine3AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine3AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine3AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine3AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine3AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine3AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine3AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine4AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine4AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine4AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine4AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine4AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine4AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine4AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine4AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine4AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine5AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine5AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine5AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine5AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine5AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine5AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine5AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine5AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine5AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine6AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine6AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine6AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine6AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine6AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine6AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine6AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine6AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine6AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine7AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine7AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine7AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine7AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine7AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine7AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine7AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine7AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine7AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine8AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine8AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine8AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine8AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine8AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine8AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine8AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine8AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine8AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine9AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine9AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine9AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine9AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine9AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine9AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine9AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine9AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine9AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine10AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine10AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine10AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine10AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine10AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine10AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine10AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine10AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine10AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine11AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine11AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine11AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine11AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine11AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine11AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine11AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine11AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine11AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine12AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine12AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine12AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine12AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine12AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine12AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine12AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine12AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine12AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine13AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine13AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine13AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine13AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine13AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine13AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine13AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine13AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine13AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine14AnyEdge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine14AnyEdge_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine14AnyEdge); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine14AnyEdgeTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine14AnyEdgeTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine14AnyEdgeTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLine14AnyEdgeFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLine14AnyEdgeFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLine14AnyEdgeFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger0_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger0); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger0Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger0Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger0Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger0FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger0FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger0FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger1Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger1Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger1Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger1FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger1FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger1FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger2_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger2); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger2Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger2Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger2Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger2FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger2FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger2FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger3_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger3); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger3Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger3Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger3Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger3FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger3FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger3FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger4_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger4); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger4Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger4Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger4Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger4FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger4FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger4FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger5_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger5_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger5); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger5Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger5Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger5Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger5FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger5FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger5FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger6_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger6); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger6Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger6Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger6Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger6FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger6FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger6FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger7_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger7_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger7); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger7Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger7Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger7Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger7FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger7FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger7FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger8_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger8_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger8); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger8Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger8Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger8Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger8FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger8FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger8FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger9_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger9_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger9); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger9Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger9Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger9Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger9FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger9FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger9FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger10_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger10_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger10); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger10Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger10Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger10Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger10FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger10FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger10FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger11_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger11_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger11); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger11Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger11Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger11Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger11FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger11FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger11FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger12_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger12_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger12); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger12Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger12Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger12Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger12FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger12FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger12FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger13_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger13_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger13); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger13Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger13Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger13Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger13FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger13FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger13FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger14_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger14_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger14); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger14Timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger14Timestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger14Timestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventLinkTrigger14FrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventLinkTrigger14FrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventLinkTrigger14FrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventError_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventError_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventError); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventErrorTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventErrorTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventErrorTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventErrorFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventErrorFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventErrorFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_EventControl_eventErrorCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventControl_eventErrorCode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventErrorCode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_EventControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::EventControl *arg1 = (mvIMPACT::acquire::GenICam::EventControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::EventControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::EventControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *EventControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__EventControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EventControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UserSetControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::UserSetControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UserSetControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UserSetControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UserSetControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::UserSetControl *)new mvIMPACT::acquire::GenICam::UserSetControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_UserSetControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::UserSetControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UserSetControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::UserSetControl *)new mvIMPACT::acquire::GenICam::UserSetControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_UserSetControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UserSetControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_UserSetControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_UserSetControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UserSetControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::UserSetControl::UserSetControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::UserSetControl::UserSetControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_UserSetControl_userSetSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserSetControl_userSetSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->userSetSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserSetControl_userSetDescription_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserSetControl_userSetDescription_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->userSetDescription); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserSetControl_userSetLoad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserSetControl_userSetLoad_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->userSetLoad); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserSetControl_userSetSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserSetControl_userSetSave_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->userSetSave); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserSetControl_userSetDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserSetControl_userSetDefault_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->userSetDefault); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserSetControl_userSetDefaultSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserSetControl_userSetDefaultSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->userSetDefaultSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserSetControl_userSetFeatureSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserSetControl_userSetFeatureSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->userSetFeatureSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserSetControl_userSetFeatureEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserSetControl_userSetFeatureEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->userSetFeatureEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_UserSetControl_mvUserData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserSetControl_mvUserData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvUserData); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_UserSetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::UserSetControl *arg1 = (mvIMPACT::acquire::GenICam::UserSetControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UserSetControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::UserSetControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::UserSetControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *UserSetControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__UserSetControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UserSetControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SequencerControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::SequencerControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SequencerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SequencerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SequencerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SequencerControl *)new mvIMPACT::acquire::GenICam::SequencerControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_SequencerControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::SequencerControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SequencerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SequencerControl *)new mvIMPACT::acquire::GenICam::SequencerControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_SequencerControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SequencerControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_SequencerControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_SequencerControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SequencerControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::SequencerControl::SequencerControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::SequencerControl::SequencerControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerConfigurationMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerConfigurationMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerConfigurationMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerFeatureSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerFeatureSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerFeatureSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerFeatureEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerFeatureEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->sequencerFeatureEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerSetSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerSetSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerSetSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerSetSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerSetSave_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->sequencerSetSave); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerSetLoad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerSetLoad_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->sequencerSetLoad); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerSetActive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerSetActive_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerSetActive); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerSetStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerSetStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerSetStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerPathSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerPathSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerPathSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerSetNext_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerSetNext_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerSetNext); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerTriggerSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerTriggerSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerTriggerSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SequencerControl_sequencerTriggerActivation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequencerControl_sequencerTriggerActivation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sequencerTriggerActivation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SequencerControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SequencerControl *arg1 = (mvIMPACT::acquire::GenICam::SequencerControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SequencerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SequencerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SequencerControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SequencerControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__SequencerControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SequencerControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvDefectivePixelCorrectionControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvDefectivePixelCorrectionControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvDefectivePixelCorrectionControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvDefectivePixelCorrectionControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *)new mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvDefectivePixelCorrectionControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvDefectivePixelCorrectionControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *)new mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvDefectivePixelCorrectionControl(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvDefectivePixelCorrectionControl", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_new_mvDefectivePixelCorrectionControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvDefectivePixelCorrectionControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvDefectivePixelCorrectionControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl::mvDefectivePixelCorrectionControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl::mvDefectivePixelCorrectionControl(mvIMPACT::acquire::Device *)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_mvDefectivePixelCorrectionControl_mvDefectPixelThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvDefectivePixelCorrectionControl_mvDefectPixelThreshold_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDefectPixelThreshold);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvDefectivePixelCorrectionControl_mvDefectivePixelEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvDefectivePixelEnable);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelBlinkingMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvDefectivePixelCorrectionControl_mvDefectivePixelBlinkingMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvDefectivePixelBlinkingMode);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvDefectivePixelCorrectionControl_mvDefectivePixelSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDefectivePixelSelector);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDefectivePixelOffsetX);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDefectivePixelOffsetY);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvDefectivePixelCorrectionControl_mvDefectivePixelCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDefectivePixelCount);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelDataLoad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvDefectivePixelCorrectionControl_mvDefectivePixelDataLoad_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::Method *)& ((arg1)->mvDefectivePixelDataLoad);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelDataSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvDefectivePixelCorrectionControl_mvDefectivePixelDataSave_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (mvIMPACT::acquire::Method *)& ((arg1)->mvDefectivePixelDataSave);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvDefectivePixelCorrectionControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *arg1 = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvDefectivePixelCorrectionControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvDefectivePixelCorrectionControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvDefectivePixelCorrectionControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvAutoFeatureControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::mvAutoFeatureControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvAutoFeatureControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvAutoFeatureControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvAutoFeatureControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *)new mvIMPACT::acquire::GenICam::mvAutoFeatureControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvAutoFeatureControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvAutoFeatureControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *)new mvIMPACT::acquire::GenICam::mvAutoFeatureControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvAutoFeatureControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvAutoFeatureControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_mvAutoFeatureControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvAutoFeatureControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvAutoFeatureControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvAutoFeatureControl::mvAutoFeatureControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvAutoFeatureControl::mvAutoFeatureControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureBrightness_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureBrightness_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureBrightness); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureSensitivity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureSensitivity_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureSensitivity); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureCharacteristic_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureCharacteristic_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureCharacteristic); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureBrightnessCalculation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureBrightnessCalculation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureBrightnessCalculation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureAOIHighlightEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureAOIHighlightEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureAOIHighlightEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureAOIMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureAOIMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureAOIMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureAOIOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureAOIOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureAOIOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureAOIOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureAOIOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureAOIOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureAOIWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureAOIWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureAOIWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureAOIHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureAOIHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureAOIHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvAutoFeatureControl_mvAutoFeatureBrightnessTolerance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvAutoFeatureControl_mvAutoFeatureBrightnessTolerance_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvAutoFeatureBrightnessTolerance); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvAutoFeatureControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvAutoFeatureControl *arg1 = (mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvAutoFeatureControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvAutoFeatureControl * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvAutoFeatureControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvAutoFeatureControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FileAccessControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::FileAccessControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileAccessControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FileAccessControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileAccessControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::FileAccessControl *)new mvIMPACT::acquire::GenICam::FileAccessControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_FileAccessControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::FileAccessControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileAccessControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::FileAccessControl *)new mvIMPACT::acquire::GenICam::FileAccessControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_FileAccessControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FileAccessControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_FileAccessControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_FileAccessControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FileAccessControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::FileAccessControl::FileAccessControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::FileAccessControl::FileAccessControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->fileSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileOperationSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileOperationSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->fileOperationSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileOperationExecute_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileOperationExecute_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->fileOperationExecute); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileOpenMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileOpenMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->fileOpenMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileAccessBuffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileAccessBuffer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->fileAccessBuffer); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileAccessOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileAccessOffset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->fileAccessOffset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileAccessLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileAccessLength_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->fileAccessLength); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileOperationStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileOperationStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->fileOperationStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileOperationResult_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileOperationResult_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->fileOperationResult); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileAccessControl_fileSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileAccessControl_fileSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->fileSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_FileAccessControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileAccessControl *arg1 = (mvIMPACT::acquire::GenICam::FileAccessControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileAccessControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileAccessControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileAccessControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *FileAccessControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileAccessControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FileAccessControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SourceControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::SourceControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SourceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SourceControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SourceControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SourceControl *)new mvIMPACT::acquire::GenICam::SourceControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SourceControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_SourceControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::SourceControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SourceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SourceControl *)new mvIMPACT::acquire::GenICam::SourceControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SourceControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_SourceControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SourceControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_SourceControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_SourceControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SourceControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::SourceControl::SourceControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::SourceControl::SourceControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_SourceControl_sourceCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SourceControl *arg1 = (mvIMPACT::acquire::GenICam::SourceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SourceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceControl_sourceCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SourceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SourceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sourceCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SourceControl_sourceSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SourceControl *arg1 = (mvIMPACT::acquire::GenICam::SourceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SourceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceControl_sourceSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SourceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SourceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sourceSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SourceControl_sourceIDValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SourceControl *arg1 = (mvIMPACT::acquire::GenICam::SourceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SourceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceControl_sourceIDValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SourceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SourceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->sourceIDValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SourceControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SourceControl *arg1 = (mvIMPACT::acquire::GenICam::SourceControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SourceControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SourceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SourceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SourceControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SourceControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__SourceControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SourceControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TransferControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::TransferControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransferControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TransferControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransferControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::TransferControl *)new mvIMPACT::acquire::GenICam::TransferControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_TransferControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::TransferControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransferControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::TransferControl *)new mvIMPACT::acquire::GenICam::TransferControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_TransferControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TransferControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_TransferControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_TransferControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TransferControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TransferControl::TransferControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::TransferControl::TransferControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_TransferControl_transferSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferControlMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferControlMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferControlMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferOperationMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferOperationMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferOperationMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferBlockCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferBlockCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferBlockCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferBurstCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferBurstCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferBurstCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferQueueMaxBlockCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferQueueMaxBlockCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferQueueMaxBlockCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferQueueCurrentBlockCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferQueueCurrentBlockCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferQueueCurrentBlockCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferQueueMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferQueueMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferQueueMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->transferStart); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferStop_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferStop_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->transferStop); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferAbort_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferAbort_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->transferAbort); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferPause_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferPause_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->transferPause); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferResume_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferResume_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->transferResume); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferTriggerSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferTriggerSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferTriggerSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferTriggerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferTriggerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferTriggerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferTriggerSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferTriggerSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferTriggerSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferTriggerActivation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferTriggerActivation_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferTriggerActivation); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferStatusSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferStatusSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferStatusSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->transferStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferComponentSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferComponentSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferComponentSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransferControl_transferStreamChannel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransferControl_transferStreamChannel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->transferStreamChannel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_TransferControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransferControl *arg1 = (mvIMPACT::acquire::GenICam::TransferControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransferControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransferControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransferControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *TransferControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransferControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TransferControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Scan3dControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::Scan3dControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Scan3dControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Scan3dControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Scan3dControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::Scan3dControl *)new mvIMPACT::acquire::GenICam::Scan3dControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_Scan3dControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::Scan3dControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Scan3dControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::Scan3dControl *)new mvIMPACT::acquire::GenICam::Scan3dControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_Scan3dControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Scan3dControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_Scan3dControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_Scan3dControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Scan3dControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::Scan3dControl::Scan3dControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::Scan3dControl::Scan3dControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dExtractionSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dExtractionSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dExtractionSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dExtractionSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dExtractionSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dExtractionSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dExtractionMethod_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dExtractionMethod_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dExtractionMethod); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dDistanceUnit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dDistanceUnit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dDistanceUnit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dCoordinateSystem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dCoordinateSystem_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dCoordinateSystem); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dOutputMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dOutputMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dOutputMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dCoordinateSystemReference_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dCoordinateSystemReference_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dCoordinateSystemReference); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dCoordinateSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dCoordinateSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dCoordinateSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dCoordinateScale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dCoordinateScale_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dCoordinateScale); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dCoordinateOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dCoordinateOffset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dCoordinateOffset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dInvalidDataFlag_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dInvalidDataFlag_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->scan3dInvalidDataFlag); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dInvalidDataValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dInvalidDataValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dInvalidDataValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dAxisMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dAxisMin_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dAxisMin); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dAxisMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dAxisMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dAxisMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dCoordinateTransformSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dCoordinateTransformSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dCoordinateTransformSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dTransformValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dTransformValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dTransformValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dCoordinateReferenceSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dCoordinateReferenceSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->scan3dCoordinateReferenceSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dCoordinateReferenceValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dCoordinateReferenceValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dCoordinateReferenceValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dFocalLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dFocalLength_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dFocalLength); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dBaseline_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dBaseline_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dBaseline); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dPrincipalPointU_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dPrincipalPointU_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dPrincipalPointU); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Scan3dControl_scan3dPrincipalPointV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scan3dControl_scan3dPrincipalPointV_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->scan3dPrincipalPointV); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_Scan3dControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::Scan3dControl *arg1 = (mvIMPACT::acquire::GenICam::Scan3dControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Scan3dControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::Scan3dControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::Scan3dControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *Scan3dControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__Scan3dControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Scan3dControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DepthControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::DepthControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DepthControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DepthControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepthControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DepthControl *)new mvIMPACT::acquire::GenICam::DepthControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_DepthControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::DepthControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DepthControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DepthControl *)new mvIMPACT::acquire::GenICam::DepthControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DepthControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DepthControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_DepthControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_DepthControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DepthControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::DepthControl::DepthControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::DepthControl::DepthControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_DepthControl_depthQuality_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthQuality_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->depthQuality); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthFill_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthFill_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->depthFill); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthSeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthSeg_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->depthSeg); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthMinConf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthMinConf_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->depthMinConf); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthMinDepth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthMinDepth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->depthMinDepth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthMaxDepth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthMaxDepth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->depthMaxDepth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthMaxDepthErr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthMaxDepthErr_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->depthMaxDepthErr); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthAcquisitionMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthAcquisitionMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->depthAcquisitionMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthAcquisitionTrigger_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthAcquisitionTrigger_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->depthAcquisitionTrigger); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthSmooth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthSmooth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->depthSmooth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthStaticScene_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthStaticScene_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->depthStaticScene); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthDoubleShot_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthDoubleShot_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->depthDoubleShot); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DepthControl_depthExposureAdaptTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthControl_depthExposureAdaptTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->depthExposureAdaptTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_DepthControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DepthControl *arg1 = (mvIMPACT::acquire::GenICam::DepthControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DepthControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DepthControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DepthControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *DepthControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__DepthControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DepthControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LightControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::LightControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LightControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LightControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LightControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::LightControl *)new mvIMPACT::acquire::GenICam::LightControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_LightControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::LightControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LightControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::LightControl *)new mvIMPACT::acquire::GenICam::LightControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_LightControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LightControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_LightControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_LightControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LightControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::LightControl::LightControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::LightControl::LightControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_LightControl_lightControllerSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LightControl *arg1 = (mvIMPACT::acquire::GenICam::LightControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LightControl_lightControllerSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LightControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LightControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->lightControllerSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LightControl_lightControllerSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LightControl *arg1 = (mvIMPACT::acquire::GenICam::LightControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LightControl_lightControllerSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LightControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LightControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->lightControllerSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LightControl_lightCurrentRating_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LightControl *arg1 = (mvIMPACT::acquire::GenICam::LightControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LightControl_lightCurrentRating_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LightControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LightControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->lightCurrentRating); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LightControl_lightVoltageRating_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LightControl *arg1 = (mvIMPACT::acquire::GenICam::LightControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LightControl_lightVoltageRating_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LightControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LightControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->lightVoltageRating); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LightControl_lightBrightness_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LightControl *arg1 = (mvIMPACT::acquire::GenICam::LightControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LightControl_lightBrightness_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LightControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LightControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->lightBrightness); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LightControl_lightConnectionStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LightControl *arg1 = (mvIMPACT::acquire::GenICam::LightControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LightControl_lightConnectionStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LightControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LightControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->lightConnectionStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LightControl_lightCurrentMeasured_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LightControl *arg1 = (mvIMPACT::acquire::GenICam::LightControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LightControl_lightCurrentMeasured_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LightControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LightControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->lightCurrentMeasured); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_LightControl_lightVoltageMeasured_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::LightControl *arg1 = (mvIMPACT::acquire::GenICam::LightControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LightControl_lightVoltageMeasured_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LightControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LightControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->lightVoltageMeasured); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_LightControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::LightControl *arg1 = (mvIMPACT::acquire::GenICam::LightControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LightControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::LightControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::LightControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *LightControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__LightControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LightControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OpticControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::OpticControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OpticControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OpticControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OpticControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::OpticControl *)new mvIMPACT::acquire::GenICam::OpticControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_OpticControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::OpticControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OpticControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::OpticControl *)new mvIMPACT::acquire::GenICam::OpticControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_OpticControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OpticControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_OpticControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_OpticControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OpticControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::OpticControl::OpticControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::OpticControl::OpticControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->opticControllerSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerInitialize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerInitialize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->opticControllerInitialize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerDisconnect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerDisconnect_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->opticControllerDisconnect); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerAbort_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerAbort_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->opticControllerAbort); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->opticControllerStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerVendorName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerVendorName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->opticControllerVendorName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerFamilyName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerFamilyName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->opticControllerFamilyName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerModelName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerModelName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->opticControllerModelName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerSerialNumber_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerSerialNumber_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->opticControllerSerialNumber); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->opticControllerVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerFirmwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerFirmwareVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->opticControllerFirmwareVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_opticControllerTemperature_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_opticControllerTemperature_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->opticControllerTemperature); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_apertureInitialize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_apertureInitialize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->apertureInitialize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_apertureStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_apertureStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->apertureStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_aperture_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_aperture_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->aperture); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_apertureStepper_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_apertureStepper_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->apertureStepper); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_numericalAperture_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_numericalAperture_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->numericalAperture); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focusInitialize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focusInitialize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->focusInitialize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focusStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focusStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->focusStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focusStepper_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focusStepper_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->focusStepper); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focusAutoMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focusAutoMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->focusAutoMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focusAuto_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focusAuto_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->focusAuto); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focalPower_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focalPower_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->focalPower); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_objectSensorDistance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_objectSensorDistance_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->objectSensorDistance); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focalLengthInitialize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focalLengthInitialize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->focalLengthInitialize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focalLengthStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focalLengthStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->focalLengthStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focalLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focalLength_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->focalLength); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_focalLengthStepper_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_focalLengthStepper_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->focalLengthStepper); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_shutterInitialize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_shutterInitialize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->shutterInitialize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_shutterStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_shutterStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->shutterStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_shutter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_shutter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->shutter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_filterInitialize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_filterInitialize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->filterInitialize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_filterStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_filterStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->filterStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_filter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_filter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->filter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_stabilizationInitialize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_stabilizationInitialize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->stabilizationInitialize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_stabilizationStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_stabilizationStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->stabilizationStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_stabilization_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_stabilization_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->stabilization); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_magnificationInitialize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_magnificationInitialize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->magnificationInitialize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_magnificationStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_magnificationStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->magnificationStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_magnification_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_magnification_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->magnification); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OpticControl_magnificationStepper_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpticControl_magnificationStepper_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->magnificationStepper); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_OpticControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::OpticControl *arg1 = (mvIMPACT::acquire::GenICam::OpticControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OpticControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::OpticControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::OpticControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *OpticControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__OpticControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OpticControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ChunkDataControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::ChunkDataControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChunkDataControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChunkDataControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChunkDataControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::ChunkDataControl *)new mvIMPACT::acquire::GenICam::ChunkDataControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_ChunkDataControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::ChunkDataControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChunkDataControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::ChunkDataControl *)new mvIMPACT::acquire::GenICam::ChunkDataControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_ChunkDataControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ChunkDataControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_ChunkDataControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_ChunkDataControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ChunkDataControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::ChunkDataControl::ChunkDataControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::ChunkDataControl::ChunkDataControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkModeActive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkModeActive_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->chunkModeActive); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkXMLEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkXMLEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->chunkXMLEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->chunkEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkRegionSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkRegionSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkRegionSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkRegionID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkRegionID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkRegionID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkRegionIDValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkRegionIDValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkRegionIDValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkComponentSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkComponentSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkComponentSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkComponentID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkComponentID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkComponentID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkComponentIDValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkComponentIDValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkComponentIDValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkGroupSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkGroupSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkGroupSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkGroupID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkGroupID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkGroupID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkImageComponent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkImageComponent_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkImageComponent); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkGroupIDValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkGroupIDValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkGroupIDValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkPartSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkPartSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkPartSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkImage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkImage_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->chunkImage); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkOffsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkOffsetX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkOffsetX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkOffsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkOffsetY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkOffsetY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkWidth_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkWidth); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkHeight_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkHeight); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkPixelFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkPixelFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkPixelFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkPixelDynamicRangeMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkPixelDynamicRangeMin_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkPixelDynamicRangeMin); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkPixelDynamicRangeMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkPixelDynamicRangeMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkPixelDynamicRangeMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkBinningHorizontal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkBinningHorizontal_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkBinningHorizontal); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkBinningVertical_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkBinningVertical_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkBinningVertical); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkDecimationHorizontal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkDecimationHorizontal_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkDecimationHorizontal); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkDecimationVertical_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkDecimationVertical_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkDecimationVertical); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkReverseX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkReverseX_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->chunkReverseX); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkReverseY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkReverseY_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->chunkReverseY); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkTimestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkTimestamp_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkTimestamp); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkTimestampLatchValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkTimestampLatchValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkTimestampLatchValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkLineStatusAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkLineStatusAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkLineStatusAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkCounterSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkCounterSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkCounterSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkCounterValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkCounterValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkCounterValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkTimerSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkTimerSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkTimerSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkTimerValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkTimerValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkTimerValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScanLineSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScanLineSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkScanLineSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkEncoderSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkEncoderSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkEncoderSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkEncoderValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkEncoderValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkEncoderValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkEncoderStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkEncoderStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkEncoderStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkExposureTimeSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkExposureTimeSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkExposureTimeSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkExposureTime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkExposureTime_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkExposureTime); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkGainSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkGainSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkGainSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkBlackLevelSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkBlackLevelSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkBlackLevelSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkBlackLevel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkBlackLevel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkBlackLevel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkLinePitch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkLinePitch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkLinePitch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkFrameID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkFrameID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkFrameID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkSourceSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkSourceSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkSourceSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkSourceID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkSourceID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkSourceID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkSourceIDValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkSourceIDValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkSourceIDValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkTransferBlockID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkTransferBlockID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkTransferBlockID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkTransferStreamID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkTransferStreamID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkTransferStreamID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkTransferQueueCurrentBlockCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkTransferQueueCurrentBlockCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkTransferQueueCurrentBlockCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkStreamChannelID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkStreamChannelID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkStreamChannelID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkSequencerSetActive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkSequencerSetActive_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkSequencerSetActive); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dDistanceUnit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dDistanceUnit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkScan3dDistanceUnit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dOutputMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dOutputMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkScan3dOutputMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dCoordinateSystem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dCoordinateSystem_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkScan3dCoordinateSystem); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dCoordinateSystemReference_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dCoordinateSystemReference_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkScan3dCoordinateSystemReference); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dCoordinateSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dCoordinateSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkScan3dCoordinateSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dCoordinateScale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dCoordinateScale_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dCoordinateScale); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dCoordinateOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dCoordinateOffset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dCoordinateOffset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dInvalidDataFlag_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dInvalidDataFlag_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->chunkScan3dInvalidDataFlag); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dInvalidDataValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dInvalidDataValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dInvalidDataValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dAxisMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dAxisMin_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dAxisMin); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dAxisMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dAxisMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dAxisMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dCoordinateTransformSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dCoordinateTransformSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkScan3dCoordinateTransformSelector);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dTransformValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dTransformValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dTransformValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dCoordinateReferenceSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dCoordinateReferenceSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkScan3dCoordinateReferenceSelector);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dCoordinateReferenceValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dCoordinateReferenceValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dCoordinateReferenceValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dFocalLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dFocalLength_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dFocalLength); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dBaseline_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dBaseline_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dBaseline); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dPrincipalPointU_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dPrincipalPointU_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dPrincipalPointU); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkScan3dPrincipalPointV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkScan3dPrincipalPointV_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkScan3dPrincipalPointV); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_mvChunkJPEG_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_mvChunkJPEG_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvChunkJPEG); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkmvCustomIdentifier_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkmvCustomIdentifier_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkmvCustomIdentifier); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkComponents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkComponents_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkComponents); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkPartIndex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkPartIndex_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->chunkPartIndex); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkRcNoise_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkRcNoise_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkRcNoise); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkRcOut1Reduction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkRcOut1Reduction_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkRcOut1Reduction); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkRcTest_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkRcTest_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->chunkRcTest); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkRcBrightness_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkRcBrightness_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->chunkRcBrightness); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ChunkDataControl_chunkRcAutoExposureAdapting_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkDataControl_chunkRcAutoExposureAdapting_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->chunkRcAutoExposureAdapting); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_ChunkDataControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::ChunkDataControl *arg1 = (mvIMPACT::acquire::GenICam::ChunkDataControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChunkDataControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::ChunkDataControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::ChunkDataControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *ChunkDataControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ChunkDataControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TestControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::TestControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TestControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TestControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::TestControl *)new mvIMPACT::acquire::GenICam::TestControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__TestControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_TestControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::TestControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TestControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::TestControl *)new mvIMPACT::acquire::GenICam::TestControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__TestControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_TestControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TestControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_TestControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_TestControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TestControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TestControl::TestControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::TestControl::TestControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_TestControl_testPendingAck_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::TestControl *arg1 = (mvIMPACT::acquire::GenICam::TestControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TestControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestControl_testPendingAck_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TestControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->testPendingAck); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TestControl_testEventGenerate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::TestControl *arg1 = (mvIMPACT::acquire::GenICam::TestControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TestControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestControl_testEventGenerate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TestControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->testEventGenerate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TestControl_testPayloadFormatMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::TestControl *arg1 = (mvIMPACT::acquire::GenICam::TestControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TestControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestControl_testPayloadFormatMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TestControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->testPayloadFormatMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_TestControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TestControl *arg1 = (mvIMPACT::acquire::GenICam::TestControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TestControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TestControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TestControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TestControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *TestControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__TestControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TestControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TransportLayerControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::TransportLayerControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransportLayerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TransportLayerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransportLayerControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::TransportLayerControl *)new mvIMPACT::acquire::GenICam::TransportLayerControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_TransportLayerControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::TransportLayerControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransportLayerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::TransportLayerControl *)new mvIMPACT::acquire::GenICam::TransportLayerControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_TransportLayerControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_TransportLayerControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_TransportLayerControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_TransportLayerControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TransportLayerControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::TransportLayerControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::TransportLayerControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_payloadSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_payloadSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->payloadSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_genDCStreamingMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_genDCStreamingMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genDCStreamingMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_genDCStreamingStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_genDCStreamingStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genDCStreamingStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_genDCDescriptor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_genDCDescriptor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->genDCDescriptor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_genDCFlowMappingTable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_genDCFlowMappingTable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->genDCFlowMappingTable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_mvU3VPHYErrorCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_mvU3VPHYErrorCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvU3VPHYErrorCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_mvU3VLNKErrorCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_mvU3VLNKErrorCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvU3VLNKErrorCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_mvU3VEndpointSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_mvU3VEndpointSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvU3VEndpointSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_mvU3VEndpointResetEventCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_mvU3VEndpointResetEventCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvU3VEndpointResetEventCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_mvU3VEndpointRetryEventCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_mvU3VEndpointRetryEventCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvU3VEndpointRetryEventCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_mvU3VErrorCounterReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_mvU3VErrorCounterReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvU3VErrorCounterReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_mvU3VSpreadSpectrumClockingSupportDisable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_mvU3VSpreadSpectrumClockingSupportDisable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvU3VSpreadSpectrumClockingSupportDisable); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_deviceTapGeometry_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_deviceTapGeometry_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceTapGeometry); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->ptpEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpClockAccuracy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpClockAccuracy_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->ptpClockAccuracy); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpDataSetLatch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpDataSetLatch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->ptpDataSetLatch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->ptpStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpServoStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpServoStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->ptpServoStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpOffsetFromMaster_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpOffsetFromMaster_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->ptpOffsetFromMaster); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpClockID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpClockID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->ptpClockID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpParentClockID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpParentClockID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->ptpParentClockID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpGrandmasterClockID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpGrandmasterClockID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->ptpGrandmasterClockID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_ptpMeanPropagationDelay_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_ptpMeanPropagationDelay_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->ptpMeanPropagationDelay); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevDeviceModeIsBigEndian_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevDeviceModeIsBigEndian_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevDeviceModeIsBigEndian); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevDeviceClass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevDeviceClass_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceClass); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevDeviceModeCharacterSet_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevDeviceModeCharacterSet_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceModeCharacterSet); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevPhysicalLinkConfiguration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevPhysicalLinkConfiguration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevPhysicalLinkConfiguration); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevCurrentPhysicalLinkConfiguration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevCurrentPhysicalLinkConfiguration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevCurrentPhysicalLinkConfiguration); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevActiveLinkCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevActiveLinkCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevActiveLinkCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSupportedOptionSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSupportedOptionSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSupportedOptionSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSupportedOption_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSupportedOption_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevSupportedOption); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevInterfaceSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevInterfaceSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevLinkSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevLinkSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevLinkSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevMACAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevMACAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevMACAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevPAUSEFrameReception_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevPAUSEFrameReception_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevPAUSEFrameReception); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevPAUSEFrameTransmission_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevPAUSEFrameTransmission_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevPAUSEFrameTransmission); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevCurrentIPConfigurationLLA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevCurrentIPConfigurationLLA_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevCurrentIPConfigurationLLA); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevCurrentIPConfigurationDHCP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevCurrentIPConfigurationDHCP_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevCurrentIPConfigurationDHCP); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevCurrentIPConfigurationPersistentIP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevCurrentIPConfigurationPersistentIP_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevCurrentIPConfigurationPersistentIP);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevCurrentIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevCurrentIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevCurrentIPAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevCurrentSubnetMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevCurrentSubnetMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevCurrentSubnetMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevCurrentDefaultGateway_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevCurrentDefaultGateway_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevCurrentDefaultGateway); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevIPConfigurationStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevIPConfigurationStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevIPConfigurationStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevFirstURL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevFirstURL_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->gevFirstURL); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSecondURL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSecondURL_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->gevSecondURL); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevNumberOfInterfaces_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevNumberOfInterfaces_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevNumberOfInterfaces); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevPersistentIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevPersistentIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevPersistentIPAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevPersistentSubnetMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevPersistentSubnetMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevPersistentSubnetMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevPersistentDefaultGateway_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevPersistentDefaultGateway_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevPersistentDefaultGateway); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevMessageChannelCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevMessageChannelCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevMessageChannelCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevStreamChannelCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevStreamChannelCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevStreamChannelCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevHeartbeatTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevHeartbeatTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevHeartbeatTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevTimestampTickFrequency_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevTimestampTickFrequency_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevTimestampTickFrequency); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevTimestampControlLatch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevTimestampControlLatch_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->gevTimestampControlLatch); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevTimestampControlReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevTimestampControlReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->gevTimestampControlReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevTimestampValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevTimestampValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevTimestampValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevDiscoveryAckDelay_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevDiscoveryAckDelay_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDiscoveryAckDelay); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevIEEE1588_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevIEEE1588_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevIEEE1588); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevIEEE1588ClockAccuracy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevIEEE1588ClockAccuracy_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevIEEE1588ClockAccuracy); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevIEEE1588Status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevIEEE1588Status_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevIEEE1588Status); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGVCPExtendedStatusCodesSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGVCPExtendedStatusCodesSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevGVCPExtendedStatusCodesSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGVCPExtendedStatusCodes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGVCPExtendedStatusCodes_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevGVCPExtendedStatusCodes); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGVCPPendingAck_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGVCPPendingAck_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevGVCPPendingAck); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGVCPHeartbeatDisable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGVCPHeartbeatDisable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevGVCPHeartbeatDisable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGVCPPendingTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGVCPPendingTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevGVCPPendingTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevPrimaryApplicationSwitchoverKey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevPrimaryApplicationSwitchoverKey_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevPrimaryApplicationSwitchoverKey); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGVSPExtendedIDMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGVSPExtendedIDMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevGVSPExtendedIDMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevCCP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevCCP_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevCCP); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevPrimaryApplicationSocket_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevPrimaryApplicationSocket_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevPrimaryApplicationSocket); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevPrimaryApplicationIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevPrimaryApplicationIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevPrimaryApplicationIPAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevMCPHostPort_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevMCPHostPort_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevMCPHostPort); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevMCDA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevMCDA_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevMCDA); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevMCTT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevMCTT_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevMCTT); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevMCRC_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevMCRC_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevMCRC); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevMCSP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevMCSP_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevMCSP); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevStreamChannelSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevStreamChannelSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevStreamChannelSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCCFGPacketResendDestination_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCCFGPacketResendDestination_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevSCCFGPacketResendDestination); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCCFGAllInTransmission_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCCFGAllInTransmission_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevSCCFGAllInTransmission); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCCFGUnconditionalStreaming_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCCFGUnconditionalStreaming_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevSCCFGUnconditionalStreaming); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCCFGExtendedChunkData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCCFGExtendedChunkData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevSCCFGExtendedChunkData); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCPDirection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCPDirection_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSCPDirection); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCPInterfaceIndex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCPInterfaceIndex_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSCPInterfaceIndex); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCPHostPort_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCPHostPort_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSCPHostPort); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCPSFireTestPacket_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCPSFireTestPacket_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevSCPSFireTestPacket); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCPSDoNotFragment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCPSDoNotFragment_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevSCPSDoNotFragment); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCPSBigEndian_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCPSBigEndian_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevSCPSBigEndian); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCPSPacketSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCPSPacketSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSCPSPacketSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCPD_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCPD_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSCPD); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCDA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCDA_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSCDA); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCSP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCSP_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSCSP); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCZoneCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCZoneCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSCZoneCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCZoneDirectionAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCZoneDirectionAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevSCZoneDirectionAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevSCZoneConfigurationLock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevSCZoneConfigurationLock_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->gevSCZoneConfigurationLock); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_aPAUSEMACCtrlFramesTransmitted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_aPAUSEMACCtrlFramesTransmitted_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->aPAUSEMACCtrlFramesTransmitted); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_aPAUSEMACCtrlFramesReceived_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_aPAUSEMACCtrlFramesReceived_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->aPAUSEMACCtrlFramesReceived); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_clConfiguration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_clConfiguration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->clConfiguration); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_clTimeSlotsCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_clTimeSlotsCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->clTimeSlotsCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkConfigurationStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkConfigurationStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkConfigurationStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkConfigurationPreferred_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkConfigurationPreferred_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkConfigurationPreferred); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkConfiguration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkConfiguration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkConfiguration); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkSharingEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkSharingEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->cxpLinkSharingEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkSharingSubDeviceSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkSharingSubDeviceSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkSharingSubDeviceSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkSharingSubDeviceType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkSharingSubDeviceType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkSharingSubDeviceType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkSharingHorizontalStripeCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkSharingHorizontalStripeCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkSharingHorizontalStripeCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkSharingVerticalStripeCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkSharingVerticalStripeCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkSharingVerticalStripeCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkSharingHorizontalOverlap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkSharingHorizontalOverlap_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkSharingHorizontalOverlap); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkSharingVerticalOverlap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkSharingVerticalOverlap_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkSharingVerticalOverlap); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpLinkSharingDuplicateStripe_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpLinkSharingDuplicateStripe_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpLinkSharingDuplicateStripe); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpConnectionSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpConnectionSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpConnectionSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpConnectionTestMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpConnectionTestMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpConnectionTestMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpConnectionTestErrorCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpConnectionTestErrorCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpConnectionTestErrorCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpSendReceiveSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpSendReceiveSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpSendReceiveSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpConnectionTestPacketCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpConnectionTestPacketCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpConnectionTestPacketCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpErrorCounterSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpErrorCounterSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpErrorCounterSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpErrorCounterReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpErrorCounterReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->cxpErrorCounterReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpErrorCounterValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpErrorCounterValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpErrorCounterValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpErrorCounterStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpErrorCounterStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpErrorCounterStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpPoCxpAuto_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpPoCxpAuto_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->cxpPoCxpAuto); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpPoCxpTurnOff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpPoCxpTurnOff_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->cxpPoCxpTurnOff); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpPoCxpTripReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpPoCxpTripReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->cxpPoCxpTripReset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpPoCxpStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpPoCxpStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->cxpPoCxpStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_cxpFirstLineTriggerWithFrameStart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_cxpFirstLineTriggerWithFrameStart_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->cxpFirstLineTriggerWithFrameStart);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_mvGevSCBWControl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_mvGevSCBWControl_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGevSCBWControl); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_mvGevSCBW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_mvGevSCBW_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGevSCBW); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; int64_type arg1 ; int64_type arg2 ; bool arg3 ; long val1 ; int ecode1 = 0 ; long val2 ;
  int ecode2 = 0 ; bool val3 ; int ecode3 = 0 ; int64_type result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "1"" of type '" "int64_type""'"); }
    arg1 = static_cast< int64_type >(val1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectivePayloadPacketsPerImage(arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; int64_type arg1 ; int64_type arg2 ; long val1 ; int ecode1 = 0 ; long val2 ; int ecode2 = 0 ;
  int64_type result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "1"" of type '" "int64_type""'"); }
    arg1 = static_cast< int64_type >(val1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectivePayloadPacketsPerImage(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  int64_type arg2 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; bool val3 ; int ecode3 = 0 ;
  int64_type result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetEffectivePayloadPacketsPerImage(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  int64_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; int64_type result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetEffectivePayloadPacketsPerImage(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage", 0, 3, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1;
    PyObject *retobj = _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_3;
    PyObject *retobj = _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 3) {
    PyObject *retobj = _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TransportLayerControl_gevGetEffectivePayloadPacketsPerImage'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectivePayloadPacketsPerImage(int64_type const,int64_type const,bool const)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectivePayloadPacketsPerImage(int64_type const,int64_type const)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectivePayloadPacketsPerImage(int64_type const,bool const) const\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectivePayloadPacketsPerImage(int64_type const) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; int64_type arg1 ; int64_type arg2 ; bool arg3 ; long val1 ; int ecode1 = 0 ; long val2 ;
  int ecode2 = 0 ; bool val3 ; int ecode3 = 0 ; int64_type result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "1"" of type '" "int64_type""'"); }
    arg1 = static_cast< int64_type >(val1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectiveBytesPerImage(arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; int64_type arg1 ; int64_type arg2 ; long val1 ; int ecode1 = 0 ; long val2 ; int ecode2 = 0 ;
  int64_type result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "1"" of type '" "int64_type""'"); }
    arg1 = static_cast< int64_type >(val1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectiveBytesPerImage(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  int64_type arg2 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; bool val3 ; int ecode3 = 0 ;
  int64_type result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetEffectiveBytesPerImage(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  int64_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; int64_type result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetEffectiveBytesPerImage(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "TransportLayerControl_gevGetEffectiveBytesPerImage", 0, 3, argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1;
    PyObject *retobj = _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_1: if (argc == 2) {
    PyObject *retobj = _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_3;
    PyObject *retobj = _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 3) {
    PyObject *retobj = _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TransportLayerControl_gevGetEffectiveBytesPerImage'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectiveBytesPerImage(int64_type const,int64_type const,bool const)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectiveBytesPerImage(int64_type const,int64_type const)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectiveBytesPerImage(int64_type const,bool const) const\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectiveBytesPerImage(int64_type const) const\n"); return 0; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; double arg1 ; int64_type arg2 ; int64_type arg3 ; bool arg4 ; double val1 ; int ecode1 = 0 ;
  long val2 ; int ecode2 = 0 ; long val3 ; int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; int64_type result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "1"" of type '" "double""'"); }
    arg1 = static_cast< double >(val1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_long(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "int64_type""'"); }
    arg3 = static_cast< int64_type >(val3); ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "4"" of type '" "bool""'"); }
    arg4 = static_cast< bool >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingBandwidth(arg1,arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; double arg1 ; int64_type arg2 ; int64_type arg3 ; double val1 ; int ecode1 = 0 ; long val2 ;
  int ecode2 = 0 ; long val3 ; int ecode3 = 0 ; int64_type result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "1"" of type '" "double""'"); }
    arg1 = static_cast< double >(val1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_long(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "int64_type""'"); }
    arg3 = static_cast< int64_type >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingBandwidth(arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  double arg2 ; int64_type arg3 ; bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; long val3 ;
  int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; int64_type result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "2"" of type '" "double""'"); }
    arg2 = static_cast< double >(val2); ecode3 = SWIG_AsVal_long(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "int64_type""'"); }
    arg3 = static_cast< int64_type >(val3); ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "4"" of type '" "bool""'"); }
    arg4 = static_cast< bool >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetResultingBandwidth(arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  double arg2 ; int64_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; long val3 ; int ecode3 = 0 ;
  int64_type result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "2"" of type '" "double""'"); }
    arg2 = static_cast< double >(val2); ecode3 = SWIG_AsVal_long(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "int64_type""'"); }
    arg3 = static_cast< int64_type >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetResultingBandwidth(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "TransportLayerControl_gevGetResultingBandwidth", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 3) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; { { int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_1;
    PyObject *retobj = _wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_1: if (argc == 3) {
    PyObject *retobj = _wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 4) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_3; { { int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    PyObject *retobj = _wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 4) {
    PyObject *retobj = _wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TransportLayerControl_gevGetResultingBandwidth'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingBandwidth(double const,int64_type const,int64_type const,bool const)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingBandwidth(double const,int64_type const,int64_type const)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingBandwidth(double const,int64_type const,bool const) const\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingBandwidth(double const,int64_type const) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; double arg1 ; int64_type arg2 ; int64_type arg3 ; int64_type arg4 ; int64_type arg5 ; bool arg6 ;
  double val1 ; int ecode1 = 0 ; long val2 ; int ecode2 = 0 ; long val3 ; int ecode3 = 0 ; long val4 ; int ecode4 = 0 ;
  long val5 ; int ecode5 = 0 ; bool val6 ; int ecode6 = 0 ; int64_type result; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "1"" of type '" "double""'"); }
    arg1 = static_cast< double >(val1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_long(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "int64_type""'"); }
    arg3 = static_cast< int64_type >(val3); ecode4 = SWIG_AsVal_long(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "int64_type""'"); }
    arg4 = static_cast< int64_type >(val4); ecode5 = SWIG_AsVal_long(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "int64_type""'"); }
    arg5 = static_cast< int64_type >(val5); ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "6"" of type '" "bool""'"); }
    arg6 = static_cast< bool >(val6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingPacketDelay(arg1,arg2,arg3,arg4,arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; double arg1 ; int64_type arg2 ; int64_type arg3 ; int64_type arg4 ; int64_type arg5 ; double val1 ;
  int ecode1 = 0 ; long val2 ; int ecode2 = 0 ; long val3 ; int ecode3 = 0 ; long val4 ; int ecode4 = 0 ; long val5 ;
  int ecode5 = 0 ; int64_type result; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "1"" of type '" "double""'"); }
    arg1 = static_cast< double >(val1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_long(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "int64_type""'"); }
    arg3 = static_cast< int64_type >(val3); ecode4 = SWIG_AsVal_long(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "int64_type""'"); }
    arg4 = static_cast< int64_type >(val4); ecode5 = SWIG_AsVal_long(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "int64_type""'"); }
    arg5 = static_cast< int64_type >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingPacketDelay(arg1,arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  double arg2 ; int64_type arg3 ; int64_type arg4 ; int64_type arg5 ; bool arg6 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ;
  int ecode2 = 0 ; long val3 ; int ecode3 = 0 ; long val4 ; int ecode4 = 0 ; long val5 ; int ecode5 = 0 ; bool val6 ;
  int ecode6 = 0 ; int64_type result; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "2"" of type '" "double""'"); }
    arg2 = static_cast< double >(val2); ecode3 = SWIG_AsVal_long(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "int64_type""'"); }
    arg3 = static_cast< int64_type >(val3); ecode4 = SWIG_AsVal_long(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "int64_type""'"); }
    arg4 = static_cast< int64_type >(val4); ecode5 = SWIG_AsVal_long(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "int64_type""'"); }
    arg5 = static_cast< int64_type >(val5); ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "6"" of type '" "bool""'"); }
    arg6 = static_cast< bool >(val6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetResultingPacketDelay(arg2,arg3,arg4,arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  double arg2 ; int64_type arg3 ; int64_type arg4 ; int64_type arg5 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ;
  int ecode2 = 0 ; long val3 ; int ecode3 = 0 ; long val4 ; int ecode4 = 0 ; long val5 ; int ecode5 = 0 ; int64_type result;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "2"" of type '" "double""'"); }
    arg2 = static_cast< double >(val2); ecode3 = SWIG_AsVal_long(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "int64_type""'"); }
    arg3 = static_cast< int64_type >(val3); ecode4 = SWIG_AsVal_long(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "int64_type""'"); }
    arg4 = static_cast< int64_type >(val4); ecode5 = SWIG_AsVal_long(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "int64_type""'"); }
    arg5 = static_cast< int64_type >(val5); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetResultingPacketDelay(arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[7] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "TransportLayerControl_gevGetResultingPacketDelay", 0, 6, argv))) SWIG_fail;
  --argc; if (argc == 5) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; { { int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_1;
    PyObject *retobj = _wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_1: if (argc == 5) {
    PyObject *retobj = _wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 6) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_3; { { int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    PyObject *retobj = _wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 6) {
    PyObject *retobj = _wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TransportLayerControl_gevGetResultingPacketDelay'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingPacketDelay(double const,int64_type const,int64_type const,int64_type const,int64_type const,bool const)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingPacketDelay(double const,int64_type const,int64_type const,int64_type const,int64_type const)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingPacketDelay(double const,int64_type const,int64_type const,int64_type const,bool const) const\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingPacketDelay(double const,int64_type const,int64_type const,int64_type const) const\n");
  return 0; }
SWIGINTERN PyObject *_wrap_delete_TransportLayerControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransportLayerControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::TransportLayerControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::TransportLayerControl * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *TransportLayerControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__TransportLayerControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TransportLayerControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvSerialInterfaceControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvSerialInterfaceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvSerialInterfaceControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvSerialInterfaceControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *)new mvIMPACT::acquire::GenICam::mvSerialInterfaceControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvSerialInterfaceControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvSerialInterfaceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *)new mvIMPACT::acquire::GenICam::mvSerialInterfaceControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvSerialInterfaceControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = {
    0} ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvSerialInterfaceControl", 0, 2, argv))) SWIG_fail; --argc;
  if (argc == 1) { PyObject *retobj = _wrap_new_mvSerialInterfaceControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvSerialInterfaceControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvSerialInterfaceControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvSerialInterfaceControl::mvSerialInterfaceControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvSerialInterfaceControl::mvSerialInterfaceControl(mvIMPACT::acquire::Device *)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvSerialInterfaceEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSerialInterfaceMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceBaudRate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceBaudRate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSerialInterfaceBaudRate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceDataBits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceDataBits_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSerialInterfaceDataBits); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceStopBits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceStopBits_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSerialInterfaceStopBits); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceParity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceParity_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSerialInterfaceParity); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceASCIIBuffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceASCIIBuffer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvSerialInterfaceASCIIBuffer); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceBinaryBuffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceBinaryBuffer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvSerialInterfaceBinaryBuffer); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceBytesToWrite_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceBytesToWrite_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSerialInterfaceBytesToWrite); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceBytesAvailableForRead_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceBytesAvailableForRead_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSerialInterfaceBytesAvailableForRead);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceReceiveStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceReceiveStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSerialInterfaceReceiveStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceBytesToRead_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceBytesToRead_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvSerialInterfaceBytesToRead); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceRead_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceRead_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvSerialInterfaceRead); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvSerialInterfaceWrite_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvSerialInterfaceWrite_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvSerialInterfaceWrite); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvLiquidLensFirmwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvLiquidLensFirmwareVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLiquidLensFirmwareVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvLiquidLensStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvLiquidLensStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLiquidLensStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvLiquidLensErrorCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvLiquidLensErrorCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLiquidLensErrorCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvLiquidLensPowerMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvLiquidLensPowerMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLiquidLensPowerMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvLiquidLensSetFocusValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvLiquidLensSetFocusValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLiquidLensSetFocusValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvLiquidLensReceiveStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvLiquidLensReceiveStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLiquidLensReceiveStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvLiquidLensSaveFocusValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvLiquidLensSaveFocusValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvLiquidLensSaveFocusValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperFirmwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperFirmwareVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStepperFirmwareVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperReceiveStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperReceiveStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStepperReceiveStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperErrorCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperErrorCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStepperErrorCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperAutoSavePositionEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperAutoSavePositionEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvStepperAutoSavePositionEnable); SWIG_PYTHON_THREAD_END_ALLOW; }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperMotorSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperMotorSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStepperMotorSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStepperStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperCurrentPosition_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperCurrentPosition_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStepperCurrentPosition); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperDesiredPosition_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperDesiredPosition_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStepperDesiredPosition); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvStepperSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperAcceleration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperAcceleration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvStepperAcceleration); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperSpeedManual_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperSpeedManual_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvStepperSpeedManual); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperPositionSetSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperPositionSetSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStepperPositionSetSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperPositionSetLoad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperPositionSetLoad_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvStepperPositionSetLoad); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperPositionSetSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperPositionSetSave_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvStepperPositionSetSave); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperMoveToHomeAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperMoveToHomeAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvStepperMoveToHomeAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvSerialInterfaceControl_mvStepperStopAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvSerialInterfaceControl_mvStepperStopAll_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvStepperStopAll); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvSerialInterfaceControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvSerialInterfaceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvSerialInterfaceControl * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvSerialInterfaceControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvSerialInterfaceControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvI2cInterfaceControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvI2cInterfaceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvI2cInterfaceControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvI2cInterfaceControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *)new mvIMPACT::acquire::GenICam::mvI2cInterfaceControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvI2cInterfaceControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvI2cInterfaceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *)new mvIMPACT::acquire::GenICam::mvI2cInterfaceControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvI2cInterfaceControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvI2cInterfaceControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_mvI2cInterfaceControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvI2cInterfaceControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvI2cInterfaceControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvI2cInterfaceControl::mvI2cInterfaceControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvI2cInterfaceControl::mvI2cInterfaceControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvI2cInterfaceEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceDeviceAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceDeviceAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvI2cInterfaceDeviceAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceDeviceSubAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceDeviceSubAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvI2cInterfaceDeviceSubAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceASCIIBuffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceASCIIBuffer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvI2cInterfaceASCIIBuffer); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceBinaryBuffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceBinaryBuffer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvI2cInterfaceBinaryBuffer); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceBytesToWrite_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceBytesToWrite_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvI2cInterfaceBytesToWrite); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceBytesToRead_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceBytesToRead_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvI2cInterfaceBytesToRead); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceRead_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceRead_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvI2cInterfaceRead); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceWrite_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceWrite_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvI2cInterfaceWrite); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvI2cInterfaceControl_mvI2cInterfaceSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvI2cInterfaceControl_mvI2cInterfaceSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvI2cInterfaceSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvI2cInterfaceControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *arg1 = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvI2cInterfaceControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvI2cInterfaceControl * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvI2cInterfaceControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvI2cInterfaceControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvLogicGateControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::mvLogicGateControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvLogicGateControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvLogicGateControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvLogicGateControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvLogicGateControl *)new mvIMPACT::acquire::GenICam::mvLogicGateControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvLogicGateControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvLogicGateControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvLogicGateControl *)new mvIMPACT::acquire::GenICam::mvLogicGateControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvLogicGateControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvLogicGateControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_mvLogicGateControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvLogicGateControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvLogicGateControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvLogicGateControl::mvLogicGateControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvLogicGateControl::mvLogicGateControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateANDSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateANDSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateANDSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateANDSource1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateANDSource1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateANDSource1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvANDSource1Inverter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvANDSource1Inverter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvANDSource1Inverter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateANDSource2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateANDSource2_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateANDSource2); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvANDSource2Inverter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvANDSource2Inverter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvANDSource2Inverter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateORSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateORSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateORSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateORSource1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateORSource1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateORSource1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateORSource2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateORSource2_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateORSource2); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateORSource3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateORSource3_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateORSource3); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateORSource4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateORSource4_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateORSource4); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateSourceSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateSourceSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateSourceSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateSource_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateSource_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateSource); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateSourceInverter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateSourceInverter_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvLogicGateSourceInverter); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateANDTermSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateANDTermSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateANDTermSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateANDTermSrc0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateANDTermSrc0_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateANDTermSrc0); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateANDTermSrc1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateANDTermSrc1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateANDTermSrc1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateORTermSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateORTermSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateORTermSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateORTermSrc0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateORTermSrc0_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateORTermSrc0); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLogicGateControl_mvLogicGateORTermSrc1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLogicGateControl_mvLogicGateORTermSrc1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLogicGateORTermSrc1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvLogicGateControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLogicGateControl *arg1 = (mvIMPACT::acquire::GenICam::mvLogicGateControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvLogicGateControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLogicGateControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLogicGateControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvLogicGateControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLogicGateControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvLogicGateControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvCurrentControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::mvCurrentControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvCurrentControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvCurrentControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvCurrentControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvCurrentControl *)new mvIMPACT::acquire::GenICam::mvCurrentControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCurrentControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvCurrentControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvCurrentControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvCurrentControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvCurrentControl *)new mvIMPACT::acquire::GenICam::mvCurrentControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCurrentControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvCurrentControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvCurrentControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_mvCurrentControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvCurrentControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvCurrentControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvCurrentControl::mvCurrentControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvCurrentControl::mvCurrentControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_mvCurrentControl_mvCurrentSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvCurrentControl *arg1 = (mvIMPACT::acquire::GenICam::mvCurrentControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCurrentControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCurrentControl_mvCurrentSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCurrentControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCurrentControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvCurrentSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCurrentControl_mvCurrent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvCurrentControl *arg1 = (mvIMPACT::acquire::GenICam::mvCurrentControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCurrentControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCurrentControl_mvCurrent_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCurrentControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCurrentControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvCurrent); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvCurrentControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvCurrentControl *arg1 = (mvIMPACT::acquire::GenICam::mvCurrentControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCurrentControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvCurrentControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCurrentControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCurrentControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvCurrentControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCurrentControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvCurrentControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvLensControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::mvLensControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvLensControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvLensControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvLensControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvLensControl *)new mvIMPACT::acquire::GenICam::mvLensControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvLensControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvLensControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvLensControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvLensControl *)new mvIMPACT::acquire::GenICam::mvLensControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvLensControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvLensControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_mvLensControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvLensControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvLensControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvLensControl::mvLensControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvLensControl::mvLensControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_mvLensControl_mvIrisType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLensControl_mvIrisType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvIrisType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLensControl_mvIrisMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLensControl_mvIrisMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvIrisMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLensControl_mvIrisSignalLevelMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLensControl_mvIrisSignalLevelMin_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvIrisSignalLevelMin); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLensControl_mvIrisSignalLevelMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLensControl_mvIrisSignalLevelMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvIrisSignalLevelMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLensControl_mvDriveSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLensControl_mvDriveSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDriveSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLensControl_mvDriveForward_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLensControl_mvDriveForward_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvDriveForward); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLensControl_mvDriveBackward_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLensControl_mvDriveBackward_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvDriveBackward); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLensControl_mvDriveDuration_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLensControl_mvDriveDuration_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDriveDuration); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvLensControl_mvDriveLevel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvLensControl_mvDriveLevel_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDriveLevel); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvLensControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvLensControl *arg1 = (mvIMPACT::acquire::GenICam::mvLensControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvLensControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvLensControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvLensControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvLensControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvLensControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvLensControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvFFCControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::mvFFCControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvFFCControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvFFCControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvFFCControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvFFCControl *)new mvIMPACT::acquire::GenICam::mvFFCControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvFFCControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvFFCControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvFFCControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvFFCControl *)new mvIMPACT::acquire::GenICam::mvFFCControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvFFCControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvFFCControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_mvFFCControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvFFCControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvFFCControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvFFCControl::mvFFCControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvFFCControl::mvFFCControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_mvFFCControl_mvFFCEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvFFCControl *arg1 = (mvIMPACT::acquire::GenICam::mvFFCControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFFCControl_mvFFCEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFFCControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFFCControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvFFCEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFFCControl_mvFFCCalibrationImageCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvFFCControl *arg1 = (mvIMPACT::acquire::GenICam::mvFFCControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFFCControl_mvFFCCalibrationImageCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFFCControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFFCControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvFFCCalibrationImageCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFFCControl_mvFFCCalibrate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvFFCControl *arg1 = (mvIMPACT::acquire::GenICam::mvFFCControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFFCControl_mvFFCCalibrate_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFFCControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFFCControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvFFCCalibrate); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFFCControl_mvFFCImageLoad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvFFCControl *arg1 = (mvIMPACT::acquire::GenICam::mvFFCControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFFCControl_mvFFCImageLoad_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFFCControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFFCControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvFFCImageLoad); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFFCControl_mvFFCImageSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvFFCControl *arg1 = (mvIMPACT::acquire::GenICam::mvFFCControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFFCControl_mvFFCImageSave_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFFCControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFFCControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvFFCImageSave); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFFCControl_mvFFCAutoLoadMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvFFCControl *arg1 = (mvIMPACT::acquire::GenICam::mvFFCControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFFCControl_mvFFCAutoLoadMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFFCControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFFCControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvFFCAutoLoadMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvFFCControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvFFCControl *arg1 = (mvIMPACT::acquire::GenICam::mvFFCControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvFFCControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFFCControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFFCControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvFFCControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFFCControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvFFCControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvFrameAverageControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::mvFrameAverageControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvFrameAverageControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvFrameAverageControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvFrameAverageControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *)new mvIMPACT::acquire::GenICam::mvFrameAverageControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvFrameAverageControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvFrameAverageControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvFrameAverageControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *)new mvIMPACT::acquire::GenICam::mvFrameAverageControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvFrameAverageControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvFrameAverageControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_mvFrameAverageControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvFrameAverageControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvFrameAverageControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvFrameAverageControl::mvFrameAverageControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvFrameAverageControl::mvFrameAverageControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_mvFrameAverageControl_mvFrameAverageMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvFrameAverageControl *arg1 = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFrameAverageControl_mvFrameAverageMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFrameAverageControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFrameAverageControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvFrameAverageMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFrameAverageControl_mvFrameAverageEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvFrameAverageControl *arg1 = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFrameAverageControl_mvFrameAverageEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFrameAverageControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFrameAverageControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvFrameAverageEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFrameAverageControl_mvFrameAverageSlope_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvFrameAverageControl *arg1 = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFrameAverageControl_mvFrameAverageSlope_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFrameAverageControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFrameAverageControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvFrameAverageSlope); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFrameAverageControl_mvFrameAverageDynamicMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvFrameAverageControl *arg1 = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFrameAverageControl_mvFrameAverageDynamicMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFrameAverageControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFrameAverageControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvFrameAverageDynamicMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFrameAverageControl_mvFrameAverageNoiseLimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvFrameAverageControl *arg1 = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFrameAverageControl_mvFrameAverageNoiseLimit_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFrameAverageControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFrameAverageControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvFrameAverageNoiseLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFrameAverageControl_mvFrameAverageNoiseGain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvFrameAverageControl *arg1 = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFrameAverageControl_mvFrameAverageNoiseGain_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFrameAverageControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFrameAverageControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvFrameAverageNoiseGain); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvFrameAverageControl_mvFrameAverageFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvFrameAverageControl *arg1 = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvFrameAverageControl_mvFrameAverageFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFrameAverageControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFrameAverageControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvFrameAverageFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvFrameAverageControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvFrameAverageControl *arg1 = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvFrameAverageControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvFrameAverageControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvFrameAverageControl * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvFrameAverageControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvFrameAverageControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mvHDRControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::mvHDRControl *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvHDRControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_mvHDRControl" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvHDRControl" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvHDRControl *)new mvIMPACT::acquire::GenICam::mvHDRControl(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_mvHDRControl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvHDRControl *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mvHDRControl" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::mvHDRControl *)new mvIMPACT::acquire::GenICam::mvHDRControl(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvHDRControl(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_mvHDRControl", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_mvHDRControl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_mvHDRControl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mvHDRControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvHDRControl::mvHDRControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvHDRControl::mvHDRControl(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDREnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDREnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvHDREnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDRPreset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDRPreset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvHDRPreset); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDRSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDRSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvHDRSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDRVoltage1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDRVoltage1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvHDRVoltage1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDRVoltage2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDRVoltage2_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvHDRVoltage2); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDRExposure1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDRExposure1_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvHDRExposure1); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDRExposure2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDRExposure2_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvHDRExposure2); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDRExposureRatio_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDRExposureRatio_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvHDRExposureRatio); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDRMotionCompensationEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDRMotionCompensationEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvHDRMotionCompensationEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvHDRControl_mvHDRAdaptiveLocalToneMappingEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvHDRControl_mvHDRAdaptiveLocalToneMappingEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvHDRAdaptiveLocalToneMappingEnable);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvHDRControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvHDRControl *arg1 = (mvIMPACT::acquire::GenICam::mvHDRControl *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvHDRControl" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvHDRControl *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvHDRControl * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvHDRControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvHDRControl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mvHDRControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SystemModule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; int64_type arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; mvIMPACT::acquire::GenICam::SystemModule *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SystemModule" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SystemModule" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SystemModule *)new mvIMPACT::acquire::GenICam::SystemModule(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_SystemModule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::SystemModule *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SystemModule" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SystemModule *)new mvIMPACT::acquire::GenICam::SystemModule(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_SystemModule__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; int64_type arg1 ; long val1 ; int ecode1 = 0 ; mvIMPACT::acquire::GenICam::SystemModule *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_long(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SystemModule" "', argument " "1"" of type '" "int64_type""'"); }
    arg1 = static_cast< int64_type >(val1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SystemModule *)new mvIMPACT::acquire::GenICam::SystemModule(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_SystemModule__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::SystemModule *)new mvIMPACT::acquire::GenICam::SystemModule();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_SystemModule(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SystemModule", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) {
    PyObject *retobj = _wrap_new_SystemModule__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 1) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Device, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_2; return _wrap_new_SystemModule__SWIG_1(self, argc, argv);}  check_2: if (argc == 1) {
    PyObject *retobj = _wrap_new_SystemModule__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_SystemModule__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SystemModule'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::SystemModule::SystemModule(mvIMPACT::acquire::Device *,int64_type)\n"
  "    mvIMPACT::acquire::GenICam::SystemModule::SystemModule(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::GenICam::SystemModule::SystemModule(int64_type)\n"
  "    mvIMPACT::acquire::GenICam::SystemModule::SystemModule()\n"); return 0; }
SWIGINTERN PyObject *_wrap_SystemModule_TLVendorName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_TLVendorName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->TLVendorName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_TLModelName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_TLModelName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->TLModelName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_TLID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_TLID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->TLID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_TLVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_TLVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->TLVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_TLFileName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_TLFileName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->TLFileName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_TLDisplayName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_TLDisplayName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->TLDisplayName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_TLPath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_TLPath_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->TLPath); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_TLType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_TLType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->TLType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_genTLVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_genTLVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genTLVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_genTLVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_genTLVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genTLVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_genTLSFNCVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_genTLSFNCVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genTLSFNCVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_genTLSFNCVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_genTLSFNCVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genTLSFNCVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_genTLSFNCVersionSubMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_genTLSFNCVersionSubMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genTLSFNCVersionSubMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_genCPVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_genCPVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genCPVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_genCPVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_genCPVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genCPVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_gevVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_gevVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_gevVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_gevVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_u3vVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_u3vVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->u3vVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_u3vVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_u3vVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->u3vVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_mvGevChannelDummyPacketSendEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_mvGevChannelDummyPacketSendEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvGevChannelDummyPacketSendEnable);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_mvGevChannelDummyPacketSendInterval_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_mvGevChannelDummyPacketSendInterval_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGevChannelDummyPacketSendInterval); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_mvInterfaceTechnologyToIgnoreSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_mvInterfaceTechnologyToIgnoreSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvInterfaceTechnologyToIgnoreSelector); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_mvInterfaceTechnologyToIgnoreEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_mvInterfaceTechnologyToIgnoreEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvInterfaceTechnologyToIgnoreEnable);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_interfaceUpdateList_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_interfaceUpdateList_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->interfaceUpdateList); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_interfaceUpdateTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_interfaceUpdateTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->interfaceUpdateTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_interfaceSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_interfaceSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->interfaceSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_interfaceID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_interfaceID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->interfaceID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_interfaceDisplayName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_interfaceDisplayName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->interfaceDisplayName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_interfaceType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_interfaceType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->interfaceType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_gevInterfaceMACAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_gevInterfaceMACAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceMACAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_gevInterfaceDefaultIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_gevInterfaceDefaultIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceDefaultIPAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_gevInterfaceDefaultSubnetMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_gevInterfaceDefaultSubnetMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceDefaultSubnetMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_gevInterfaceDefaultGateway_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_gevInterfaceDefaultGateway_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceDefaultGateway); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_mvGevInterfaceMTU_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_mvGevInterfaceMTU_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGevInterfaceMTU); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_mvGevInterfaceLinkSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_mvGevInterfaceLinkSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGevInterfaceLinkSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_mvDeviceUpdateListBehaviour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_mvDeviceUpdateListBehaviour_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceUpdateListBehaviour); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_eventSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_eventSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_eventNotification_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_eventNotification_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventNotification); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_getSystemModuleCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; int64_type result;
  if (!SWIG_Python_UnpackTuple(args, "SystemModule_getSystemModuleCount", 0, 0, 0)) SWIG_fail; { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (int64_type)mvIMPACT::acquire::GenICam::SystemModule::getSystemModuleCount();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_SystemModule_getInterfaceModuleCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int64_type result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SystemModule_getInterfaceModuleCount" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int64_type)(arg1)->getInterfaceModuleCount(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_SystemModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SystemModule *arg1 = (mvIMPACT::acquire::GenICam::SystemModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SystemModule" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *SystemModule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SystemModule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InterfaceModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::SystemModule *arg1 = 0 ; int64_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ;
  int ecode2 = 0 ; PyObject *swig_obj[2] ; mvIMPACT::acquire::GenICam::InterfaceModule *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args, "new_InterfaceModule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mvIMPACT__acquire__GenICam__SystemModule,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InterfaceModule" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterfaceModule" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::SystemModule const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::SystemModule * >(argp1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InterfaceModule" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::InterfaceModule *)new mvIMPACT::acquire::GenICam::InterfaceModule((mvIMPACT::acquire::GenICam::SystemModule const &)*arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_interfaceID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_interfaceID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->interfaceID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_interfaceDisplayName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_interfaceDisplayName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->interfaceDisplayName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_interfaceType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_interfaceType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->interfaceType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_interfaceTLVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_interfaceTLVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->interfaceTLVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_interfaceTLVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_interfaceTLVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->interfaceTLVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvInterfaceLicenseFile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvInterfaceLicenseFile_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvInterfaceLicenseFile); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevInterfaceGatewaySelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevInterfaceGatewaySelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceGatewaySelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevInterfaceGateway_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevInterfaceGateway_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceGateway); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevInterfaceMACAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevInterfaceMACAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceMACAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevInterfaceSubnetSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevInterfaceSubnetSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceSubnetSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevInterfaceSubnetIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevInterfaceSubnetIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceSubnetIPAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevInterfaceSubnetMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevInterfaceSubnetMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevInterfaceSubnetMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvGevInterfaceMTU_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvGevInterfaceMTU_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGevInterfaceMTU); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvGevInterfaceLinkSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvGevInterfaceLinkSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvGevInterfaceLinkSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvGevAdvancedDeviceDiscoveryEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvGevAdvancedDeviceDiscoveryEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvGevAdvancedDeviceDiscoveryEnable);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceUpdateList_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceUpdateList_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->deviceUpdateList); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvUnicastDeviceDiscoveryCommandCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvUnicastDeviceDiscoveryCommandCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvUnicastDeviceDiscoveryCommandCount); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvUnicastDeviceDiscoveryCommandSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvUnicastDeviceDiscoveryCommandSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvUnicastDeviceDiscoveryCommandSelector);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvUnicastDeviceDiscoveryDestinationIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvUnicastDeviceDiscoveryDestinationIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvUnicastDeviceDiscoveryDestinationIPAddress);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceUpdateTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceUpdateTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceUpdateTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceVendorName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceVendorName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceVendorName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceModelName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceModelName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceModelName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceLinkSpeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceLinkSpeed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceLinkSpeed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceAccessStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceAccessStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceAccessStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceSerialNumber_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceSerialNumber_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceSerialNumber); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvU3VDeviceGUID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvU3VDeviceGUID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvU3VDeviceGUID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceUserID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceUserID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceUserID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceTLVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceTLVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceTLVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_deviceTLVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_deviceTLVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceTLVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevDeviceIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevDeviceIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceIPAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevDeviceSubnetMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevDeviceSubnetMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceSubnetMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevDeviceGateway_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevDeviceGateway_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceGateway); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevDeviceIPConfigurationStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevDeviceIPConfigurationStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceIPConfigurationStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevDeviceMACAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevDeviceMACAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceMACAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevCurrentControlMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevCurrentControlMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevCurrentControlMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvDeviceCommandChannelTransmissionTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvDeviceCommandChannelTransmissionTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceCommandChannelTransmissionTimeout);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvDeviceCommandChannelRetryCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvDeviceCommandChannelRetryCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceCommandChannelRetryCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_genCPVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_genCPVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genCPVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_genCPVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_genCPVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genCPVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_u3vVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_u3vVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->u3vVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_u3vVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_u3vVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->u3vVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvDevicePrimaryApplicationSwitchoverSupported_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvDevicePrimaryApplicationSwitchoverSupported_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvDevicePrimaryApplicationSwitchoverSupported);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvDevicePrimaryApplicationSwitchoverEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvDevicePrimaryApplicationSwitchoverEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvDevicePrimaryApplicationSwitchoverEnable);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevApplicationSwitchoverKey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevApplicationSwitchoverKey_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevApplicationSwitchoverKey); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvDeviceNetworkInterfaceCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvDeviceNetworkInterfaceCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvDeviceNetworkInterfaceCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevDeviceForceIP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevDeviceForceIP_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->gevDeviceForceIP); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevDeviceForceIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevDeviceForceIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceForceIPAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevDeviceForceSubnetMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevDeviceForceSubnetMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceForceSubnetMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevDeviceForceGateway_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevDeviceForceGateway_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceForceGateway); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvDeviceUpdateFirmware_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvDeviceUpdateFirmware_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvDeviceUpdateFirmware); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvDeviceLicenseValid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvDeviceLicenseValid_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvDeviceLicenseValid); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvDeviceLicenseDetails_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvDeviceLicenseDetails_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvDeviceLicenseDetails); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_actionCommand_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::Method *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_actionCommand_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->actionCommand); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Method, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_actionDeviceKey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_actionDeviceKey_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionDeviceKey); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_actionGroupKey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_actionGroupKey_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionGroupKey); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_actionGroupMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_actionGroupMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionGroupMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_actionScheduledTimeEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_actionScheduledTimeEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->actionScheduledTimeEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_actionScheduledTime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_actionScheduledTime_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->actionScheduledTime); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_gevActionDestinationIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_gevActionDestinationIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevActionDestinationIPAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvActionAcknowledgeEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvActionAcknowledgeEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvActionAcknowledgeEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvActionAcknowledgesExpected_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvActionAcknowledgesExpected_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvActionAcknowledgesExpected); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvActionAcknowledgeTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvActionAcknowledgeTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvActionAcknowledgeTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvActionAcknowledgesReceived_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvActionAcknowledgesReceived_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvActionAcknowledgesReceived); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_mvActionAcknowledgesFailed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_mvActionAcknowledgesFailed_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvActionAcknowledgesFailed); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_eventSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_eventSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InterfaceModule_eventNotification_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterfaceModule_eventNotification_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventNotification); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_InterfaceModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::InterfaceModule *arg1 = (mvIMPACT::acquire::GenICam::InterfaceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterfaceModule" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::InterfaceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::InterfaceModule * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *InterfaceModule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__InterfaceModule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InterfaceModule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DeviceModule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::DeviceModule *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeviceModule" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DeviceModule" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeviceModule" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DeviceModule *)new mvIMPACT::acquire::GenICam::DeviceModule(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceModule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::DeviceModule *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeviceModule" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DeviceModule *)new mvIMPACT::acquire::GenICam::DeviceModule(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DeviceModule(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DeviceModule", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_DeviceModule__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_DeviceModule__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DeviceModule'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::DeviceModule::DeviceModule(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::DeviceModule::DeviceModule(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceSerialNumber_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceSerialNumber_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceSerialNumber); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceUserID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceUserID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceUserID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceVendorName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceVendorName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceVendorName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceModelName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceModelName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceModelName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceFamilyName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceFamilyName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceFamilyName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceVersion_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_mvU3VDeviceGUID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_mvU3VDeviceGUID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvU3VDeviceGUID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceManufacturerInfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceManufacturerInfo_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceManufacturerInfo); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceDisplayName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceDisplayName_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceDisplayName); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceTimestampFrequency_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceTimestampFrequency_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceTimestampFrequency); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceAccessStatus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceAccessStatus_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceAccessStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceChunkDataFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceChunkDataFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceChunkDataFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceEventDataFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceEventDataFormat_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceEventDataFormat); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_gevDeviceMACAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_gevDeviceMACAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceMACAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_gevDeviceIPAddress_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_gevDeviceIPAddress_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceIPAddress); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_gevDeviceSubnetMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_gevDeviceSubnetMask_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceSubnetMask); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_gevDeviceGateway_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_gevDeviceGateway_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevDeviceGateway); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_gevVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_gevVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_gevVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_gevVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->gevVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_genCPVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_genCPVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genCPVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_genCPVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_genCPVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->genCPVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_u3vVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_u3vVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->u3vVersionMajor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_u3vVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_u3vVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->u3vVersionMinor); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_mvDeviceLicenseValid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ;
  if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_mvDeviceLicenseValid_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvDeviceLicenseValid); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_mvDeviceLicenseDetails_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_mvDeviceLicenseDetails_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvDeviceLicenseDetails); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_deviceEndianessMechanism_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_deviceEndianessMechanism_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->deviceEndianessMechanism); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_linkCommandTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_linkCommandTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->linkCommandTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_mvLinkCommandTimeoutCheckGranularity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_mvLinkCommandTimeoutCheckGranularity_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLinkCommandTimeoutCheckGranularity); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_linkCommandRetryCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_linkCommandRetryCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->linkCommandRetryCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_streamSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_streamSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_streamID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_streamID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->streamID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_eventSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_eventSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceModule_eventNotification_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceModule_eventNotification_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventNotification); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_DeviceModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DeviceModule *arg1 = (mvIMPACT::acquire::GenICam::DeviceModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeviceModule" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DeviceModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DeviceModule * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *DeviceModule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__DeviceModule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DeviceModule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DataStreamModule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; int64_type arg2 ;
  std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; int res3 = SWIG_OLDOBJ ;
  mvIMPACT::acquire::GenICam::DataStreamModule *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataStreamModule" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DataStreamModule" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); { std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DataStreamModule" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataStreamModule" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DataStreamModule *)new mvIMPACT::acquire::GenICam::DataStreamModule(arg1,arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res3)) delete arg3; return NULL; }
SWIGINTERN PyObject *_wrap_new_DataStreamModule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; int64_type arg2 ;
  void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; mvIMPACT::acquire::GenICam::DataStreamModule *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataStreamModule" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DataStreamModule" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::DataStreamModule *)new mvIMPACT::acquire::GenICam::DataStreamModule(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_DataStreamModule(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DataStreamModule", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) {
    PyObject *retobj = _wrap_new_DataStreamModule__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_new_DataStreamModule__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DataStreamModule'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::DataStreamModule::DataStreamModule(mvIMPACT::acquire::Device *,int64_type,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::DataStreamModule::DataStreamModule(mvIMPACT::acquire::Device *,int64_type)\n"); return 0; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamID_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->streamID); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvStreamDriverTechnology_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyS *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvStreamDriverTechnology_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvStreamDriverTechnology); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__PropertyS, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvAutoJoinMulticastGroups_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvAutoJoinMulticastGroups_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvAutoJoinMulticastGroups); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendActive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendActive_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvResendActive); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendUserControlledEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendUserControlledEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvResendUserControlledEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvResendMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendBatchingActive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendBatchingActive_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvResendBatchingActive); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendMaximumGapSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendMaximumGapSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvResendMaximumGapSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendThreshold_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvResendThreshold); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendRequestMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendRequestMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvResendRequestMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendRequestCredits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyF *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendRequestCredits_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyF *)& ((arg1)->mvResendRequestCredits); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendResponseTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendResponseTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvResendResponseTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendsPerTimeout_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvResendsPerTimeout_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvResendsPerTimeout); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvMultiCoreAcquisitionEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvMultiCoreAcquisitionEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvMultiCoreAcquisitionEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvMultiCoreAcquisitionBaseCore_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvMultiCoreAcquisitionBaseCore_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvMultiCoreAcquisitionBaseCore); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvMultiCoreAcquisitionCoreCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvMultiCoreAcquisitionCoreCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvMultiCoreAcquisitionCoreCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvMultiCoreAcquisitionFirstCoreIndex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvMultiCoreAcquisitionFirstCoreIndex_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvMultiCoreAcquisitionFirstCoreIndex); SWIG_PYTHON_THREAD_END_ALLOW; }
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvMultiCoreAcquisitionCoreSwitchInterval_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvMultiCoreAcquisitionCoreSwitchInterval_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvMultiCoreAcquisitionCoreSwitchInterval);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvV4L2MemoryMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvV4L2MemoryMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvV4L2MemoryMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvMMAPBufferCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvMMAPBufferCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvMMAPBufferCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvLowLatencyModeEnable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvLowLatencyModeEnable_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->mvLowLatencyModeEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamAnnouncedBufferCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamAnnouncedBufferCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamAnnouncedBufferCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamBufferHandlingMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamBufferHandlingMode_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamBufferHandlingMode); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamAnnounceBufferMinimum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamAnnounceBufferMinimum_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamAnnounceBufferMinimum); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvStreamAnnounceBufferMaximum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_mvStreamAnnounceBufferMaximum_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStreamAnnounceBufferMaximum); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamDeliveredFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamDeliveredFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamDeliveredFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamLostFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamLostFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamLostFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamInputBufferCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamInputBufferCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamInputBufferCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamOutputBufferCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamOutputBufferCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamOutputBufferCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamStartedFrameCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamStartedFrameCount_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamStartedFrameCount); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_payloadSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_payloadSize_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->payloadSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamIsGrabbing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyIBoolean *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamIsGrabbing_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIBoolean *)& ((arg1)->streamIsGrabbing); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamChunkCountMaximum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamChunkCountMaximum_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamChunkCountMaximum); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_streamBufferAlignment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_streamBufferAlignment_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->streamBufferAlignment); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_eventSelector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_eventSelector_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventSelector); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_eventNotification_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataStreamModule_eventNotification_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->eventNotification); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_DataStreamModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::DataStreamModule *arg1 = (mvIMPACT::acquire::GenICam::DataStreamModule *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataStreamModule" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::DataStreamModule *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::DataStreamModule * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *DataStreamModule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DataStreamModule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CustomCommandGenerator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; std::string *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; mvIMPACT::acquire::GenICam::CustomCommandGenerator *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomCommandGenerator" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CustomCommandGenerator" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomCommandGenerator" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *)new mvIMPACT::acquire::GenICam::CustomCommandGenerator(arg1,(std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: if (SWIG_IsNewObj(res2)) delete arg2; return NULL; }
SWIGINTERN PyObject *_wrap_new_CustomCommandGenerator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__Device, 0 |  0 ); if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomCommandGenerator" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *)new mvIMPACT::acquire::GenICam::CustomCommandGenerator(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_CustomCommandGenerator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0}
  ; if (!(argc = SWIG_Python_UnpackTuple(args, "new_CustomCommandGenerator", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) {
    PyObject *retobj = _wrap_new_CustomCommandGenerator__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 2) {
    PyObject *retobj = _wrap_new_CustomCommandGenerator__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CustomCommandGenerator'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::CustomCommandGenerator(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::CustomCommandGenerator(mvIMPACT::acquire::Device *)\n"); return 0; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_discardCommandBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_discardCommandBuffer" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; (arg1)->discardCommandBuffer(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ;
  unsigned int arg8 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ;
  int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int val7 ; int ecode7 = 0 ; unsigned int val8 ;
  int ecode8 = 0 ; int result; if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "7"" of type '" "mvIMPACT::acquire::GenICam::TRequestTransmissionMode""'"); }
    arg7 = static_cast< mvIMPACT::acquire::GenICam::TRequestTransmissionMode >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "8"" of type '" "unsigned int""'"); }
    arg8 = static_cast< unsigned int >(val8); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueTransmissionRequest(arg2,arg3,arg4,arg5,arg6,arg7,arg8); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ;
  void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int val7 ; int ecode7 = 0 ; int result;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "7"" of type '" "mvIMPACT::acquire::GenICam::TRequestTransmissionMode""'"); }
    arg7 = static_cast< mvIMPACT::acquire::GenICam::TRequestTransmissionMode >(val7); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueTransmissionRequest(arg2,arg3,arg4,arg5,arg6,arg7); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int result;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueTransmissionRequest(arg2,arg3,arg4,arg5,arg6); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ;
  mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ; unsigned int arg8 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ;
  int val6 ; int ecode6 = 0 ; int val7 ; int ecode7 = 0 ; unsigned int val8 ; int ecode8 = 0 ; int result;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "7"" of type '" "mvIMPACT::acquire::GenICam::TRequestTransmissionMode""'"); }
    arg7 = static_cast< mvIMPACT::acquire::GenICam::TRequestTransmissionMode >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "8"" of type '" "unsigned int""'"); }
    arg8 = static_cast< unsigned int >(val8); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ;
  mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int val7 ;
  int ecode7 = 0 ; int result; if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "7"" of type '" "mvIMPACT::acquire::GenICam::TRequestTransmissionMode""'"); }
    arg7 = static_cast< mvIMPACT::acquire::GenICam::TRequestTransmissionMode >(val7); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6,arg7);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ;
  void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int result; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; unsigned int val3 ; int ecode3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[9] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CustomCommandGenerator_queueTransmissionRequest", 0, 8, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 6) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Request, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_3; PyObject *retobj = _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 6) {
    PyObject *retobj = _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 7) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Request, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_5; PyObject *retobj = _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_5: if (argc == 7) {
    PyObject *retobj = _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 8) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Request, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_7; PyObject *retobj = _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_7: if (argc == 8) {
    PyObject *retobj = _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CustomCommandGenerator_queueTransmissionRequest'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest(int64_type,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode,unsigned int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest(int64_type,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest(int64_type,int,int,int,int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest(mvIMPACT::acquire::Request const *,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode,unsigned int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest(mvIMPACT::acquire::Request const *,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest(mvIMPACT::acquire::Request const *,int,int,int,int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest(mvIMPACT::acquire::Request const *,unsigned int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest(mvIMPACT::acquire::Request const *)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ;
  unsigned int arg8 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ;
  int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int val7 ; int ecode7 = 0 ; unsigned int val8 ;
  int ecode8 = 0 ; int result; if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "7"" of type '" "mvIMPACT::acquire::GenICam::TRequestTransmissionMode""'"); }
    arg7 = static_cast< mvIMPACT::acquire::GenICam::TRequestTransmissionMode >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "8"" of type '" "unsigned int""'"); }
    arg8 = static_cast< unsigned int >(val8); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->requestTransmission(arg2,arg3,arg4,arg5,arg6,arg7,arg8); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ;
  void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int val7 ; int ecode7 = 0 ; int result;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "7"" of type '" "mvIMPACT::acquire::GenICam::TRequestTransmissionMode""'"); }
    arg7 = static_cast< mvIMPACT::acquire::GenICam::TRequestTransmissionMode >(val7); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->requestTransmission(arg2,arg3,arg4,arg5,arg6,arg7); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ;
  int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int result;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->requestTransmission(arg2,arg3,arg4,arg5,arg6); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ;
  mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ; unsigned int arg8 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ;
  int val6 ; int ecode6 = 0 ; int val7 ; int ecode7 = 0 ; unsigned int val8 ; int ecode8 = 0 ; int result;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "7"" of type '" "mvIMPACT::acquire::GenICam::TRequestTransmissionMode""'"); }
    arg7 = static_cast< mvIMPACT::acquire::GenICam::TRequestTransmissionMode >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "8"" of type '" "unsigned int""'"); }
    arg8 = static_cast< unsigned int >(val8); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ;
  mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int val7 ;
  int ecode7 = 0 ; int result; if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "7"" of type '" "mvIMPACT::acquire::GenICam::TRequestTransmissionMode""'"); }
    arg7 = static_cast< mvIMPACT::acquire::GenICam::TRequestTransmissionMode >(val7); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6,arg7);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ;
  void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ;
  int val5 ; int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; int result; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "6"" of type '" "int""'"); }
    arg6 = static_cast< int >(val6); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; unsigned int arg3 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; unsigned int val3 ; int ecode3 = 0 ; int result; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "3"" of type '" "unsigned int""'"); }
    arg3 = static_cast< unsigned int >(val3); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; }
       }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::Request *arg2 = (mvIMPACT::acquire::Request *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; int result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp2); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[9] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CustomCommandGenerator_requestTransmission", 0, 8, argv))) SWIG_fail; --argc;
  if (argc == 2) { PyObject *retobj = _wrap_CustomCommandGenerator_requestTransmission__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 3) {
    PyObject *retobj = _wrap_CustomCommandGenerator_requestTransmission__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 6) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Request, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_3; PyObject *retobj = _wrap_CustomCommandGenerator_requestTransmission__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_3: if (argc == 6) {
    PyObject *retobj = _wrap_CustomCommandGenerator_requestTransmission__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 7) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Request, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_5; PyObject *retobj = _wrap_CustomCommandGenerator_requestTransmission__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_5: if (argc == 7) {
    PyObject *retobj = _wrap_CustomCommandGenerator_requestTransmission__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  if (argc == 8) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mvIMPACT__acquire__Request, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_7; PyObject *retobj = _wrap_CustomCommandGenerator_requestTransmission__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  check_7: if (argc == 8) {
    PyObject *retobj = _wrap_CustomCommandGenerator_requestTransmission__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CustomCommandGenerator_requestTransmission'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::requestTransmission(int64_type,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode,unsigned int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::requestTransmission(int64_type,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::requestTransmission(int64_type,int,int,int,int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::requestTransmission(mvIMPACT::acquire::Request const *,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode,unsigned int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::requestTransmission(mvIMPACT::acquire::Request const *,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::requestTransmission(mvIMPACT::acquire::Request const *,int,int,int,int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::requestTransmission(mvIMPACT::acquire::Request const *,unsigned int)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::requestTransmission(mvIMPACT::acquire::Request const *)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_modifySequencerSetValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; mvIMPACT::acquire::GenICam::TSequencerSetParameter arg3 ; int64_type arg4 ; void *argp1 = 0 ; int res1 = 0 ;
  long val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; long val4 ; int ecode4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "3"" of type '" "mvIMPACT::acquire::GenICam::TSequencerSetParameter""'"); }
    arg3 = static_cast< mvIMPACT::acquire::GenICam::TSequencerSetParameter >(val3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "4"" of type '" "int64_type""'"); }
    arg4 = static_cast< int64_type >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->modifySequencerSetValue(arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_modifySequencerSetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; mvIMPACT::acquire::GenICam::TSequencerSetParameter arg3 ; double arg4 ; void *argp1 = 0 ; int res1 = 0 ;
  long val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "3"" of type '" "mvIMPACT::acquire::GenICam::TSequencerSetParameter""'"); }
    arg3 = static_cast< mvIMPACT::acquire::GenICam::TSequencerSetParameter >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "4"" of type '" "double""'"); }
    arg4 = static_cast< double >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->modifySequencerSetValue(arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_modifySequencerSetValue(PyObject *self, PyObject *args) { Py_ssize_t argc;
  PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CustomCommandGenerator_modifySequencerSetValue", 0, 4, argv))) SWIG_fail; --argc;
  if (argc == 4) { int _v = 0; { { int res = SWIG_AsVal_long(argv[3], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_CustomCommandGenerator_modifySequencerSetValue__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 4) { PyObject *retobj = _wrap_CustomCommandGenerator_modifySequencerSetValue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CustomCommandGenerator_modifySequencerSetValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::modifySequencerSetValue(int64_type const,mvIMPACT::acquire::GenICam::TSequencerSetParameter const,int64_type const)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::modifySequencerSetValue(int64_type const,mvIMPACT::acquire::GenICam::TSequencerSetParameter const,double const)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueSequencerSetValueModification__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; mvIMPACT::acquire::GenICam::TSequencerSetParameter arg3 ; int64_type arg4 ; void *argp1 = 0 ; int res1 = 0 ;
  long val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; long val4 ; int ecode4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "3"" of type '" "mvIMPACT::acquire::GenICam::TSequencerSetParameter""'"); }
    arg3 = static_cast< mvIMPACT::acquire::GenICam::TSequencerSetParameter >(val3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "4"" of type '" "int64_type""'"); }
    arg4 = static_cast< int64_type >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueSequencerSetValueModification(arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueSequencerSetValueModification__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  int64_type arg2 ; mvIMPACT::acquire::GenICam::TSequencerSetParameter arg3 ; double arg4 ; void *argp1 = 0 ; int res1 = 0 ;
  long val2 ; int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; int result;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "2"" of type '" "int64_type""'"); }
    arg2 = static_cast< int64_type >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "3"" of type '" "mvIMPACT::acquire::GenICam::TSequencerSetParameter""'"); }
    arg3 = static_cast< mvIMPACT::acquire::GenICam::TSequencerSetParameter >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "4"" of type '" "double""'"); }
    arg4 = static_cast< double >(val4); { try { { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)(arg1)->queueSequencerSetValueModification(arg2,arg3,arg4); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueSequencerSetValueModification(PyObject *self, PyObject *args) {
  Py_ssize_t argc; PyObject *argv[5] = { 0} ;
  if (!(argc = SWIG_Python_UnpackTuple(args, "CustomCommandGenerator_queueSequencerSetValueModification", 0, 4, argv))) SWIG_fail;
  --argc; if (argc == 4) { int _v = 0; { { int res = SWIG_AsVal_long(argv[3], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_1; return _wrap_CustomCommandGenerator_queueSequencerSetValueModification__SWIG_0(self, argc, argv);} 
  check_1: if (argc == 4) {
    PyObject *retobj = _wrap_CustomCommandGenerator_queueSequencerSetValueModification__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;}  fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CustomCommandGenerator_queueSequencerSetValueModification'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueSequencerSetValueModification(int64_type const,mvIMPACT::acquire::GenICam::TSequencerSetParameter const,int64_type const)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueSequencerSetValueModification(int64_type const,mvIMPACT::acquire::GenICam::TSequencerSetParameter const,double const)\n");
  return 0; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_sendCommandBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_sendCommandBuffer" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; result = (int)(arg1)->sendCommandBuffer(); SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_commandBufferSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_commandBufferSize" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::GenICam::CustomCommandGenerator const *)arg1)->commandBufferSize();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_commandBufferSizeUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; unsigned int result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomCommandGenerator_commandBufferSizeUsed" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (unsigned int)((mvIMPACT::acquire::GenICam::CustomCommandGenerator const *)arg1)->commandBufferSizeUsed();
        SWIG_PYTHON_THREAD_END_ALLOW; }  }  catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
      handleImpactAcquireException( e ); SWIG_fail; }  catch(const std::out_of_range &e) {
      SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; }  catch(const std::exception &e) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_CustomCommandGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CustomCommandGenerator" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::CustomCommandGenerator *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::CustomCommandGenerator * >(argp1); { try { {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW; delete arg1; SWIG_PYTHON_THREAD_END_ALLOW; }  } 
    catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException( e ); SWIG_fail; } 
    catch(const std::out_of_range &e) { SWIG_SetErrorMsg(PyExc_IndexError, e.what()); SWIG_fail; } 
    catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
      SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  resultobj = SWIG_Py_Void();
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CustomCommandGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CustomCommandGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

static PyMethodDef SwigMethods[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, NULL},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, NULL},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, NULL},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, NULL},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "ChannelData_iChannelOffset_set", _wrap_ChannelData_iChannelOffset_set, METH_VARARGS, " The offset (in bytes) to the next channel."},
	 { "ChannelData_iChannelOffset_get", _wrap_ChannelData_iChannelOffset_get, METH_O, " The offset (in bytes) to the next channel."},
	 { "ChannelData_iLinePitch_set", _wrap_ChannelData_iLinePitch_set, METH_VARARGS, " The offset (in bytes) to the next line of this channel."},
	 { "ChannelData_iLinePitch_get", _wrap_ChannelData_iLinePitch_get, METH_O, " The offset (in bytes) to the next line of this channel."},
	 { "ChannelData_iPixelPitch_set", _wrap_ChannelData_iPixelPitch_set, METH_VARARGS, " The offset (in bytes) to the next pixel of this channel."},
	 { "ChannelData_iPixelPitch_get", _wrap_ChannelData_iPixelPitch_get, METH_O, " The offset (in bytes) to the next pixel of this channel."},
	 { "ChannelData_szChannelDesc_set", _wrap_ChannelData_szChannelDesc_set, METH_VARARGS, "\n"
		"The string descriptor for this channel.\n"
		"For an RGB image the string values of three **mvIMPACT::acquire::ChannelData**\n"
		"structures this might e.g. be \"R\", \"G\" and \"B\".\n"
		""},
	 { "ChannelData_szChannelDesc_get", _wrap_ChannelData_szChannelDesc_get, METH_O, "\n"
		"The string descriptor for this channel.\n"
		"For an RGB image the string values of three **mvIMPACT::acquire::ChannelData**\n"
		"structures this might e.g. be \"R\", \"G\" and \"B\".\n"
		""},
	 { "new_ChannelData", _wrap_new_ChannelData, METH_NOARGS, NULL},
	 { "delete_ChannelData", _wrap_delete_ChannelData, METH_O, NULL},
	 { "ChannelData_swigregister", ChannelData_swigregister, METH_O, NULL},
	 { "ChannelData_swiginit", ChannelData_swiginit, METH_VARARGS, NULL},
	 { "ImageBuffer_iBytesPerPixel_set", _wrap_ImageBuffer_iBytesPerPixel_set, METH_VARARGS, " The number of bytes per pixel."},
	 { "ImageBuffer_iBytesPerPixel_get", _wrap_ImageBuffer_iBytesPerPixel_get, METH_O, " The number of bytes per pixel."},
	 { "ImageBuffer_iHeight_set", _wrap_ImageBuffer_iHeight_set, METH_VARARGS, " The height of the image in pixel or lines."},
	 { "ImageBuffer_iHeight_get", _wrap_ImageBuffer_iHeight_get, METH_O, " The height of the image in pixel or lines."},
	 { "ImageBuffer_iWidth_set", _wrap_ImageBuffer_iWidth_set, METH_VARARGS, " The width of the image in pixel."},
	 { "ImageBuffer_iWidth_get", _wrap_ImageBuffer_iWidth_get, METH_O, " The width of the image in pixel."},
	 { "ImageBuffer_pixelFormat_set", _wrap_ImageBuffer_pixelFormat_set, METH_VARARGS, "\n"
		"The pixel format of this image.\n"
		"This might be important, when the image data needs to be processed or stored in\n"
		"a file or maybe even if the image shall be displayed.\n"
		""},
	 { "ImageBuffer_pixelFormat_get", _wrap_ImageBuffer_pixelFormat_get, METH_O, "\n"
		"The pixel format of this image.\n"
		"This might be important, when the image data needs to be processed or stored in\n"
		"a file or maybe even if the image shall be displayed.\n"
		""},
	 { "ImageBuffer_iSize_set", _wrap_ImageBuffer_iSize_set, METH_VARARGS, "\n"
		"The size (in bytes) of the whole image.\n"
		"This value in connection with **mvIMPACT::acquire::ImageBuffer::vpData**\n"
		"is sufficient to copy the complete image without having any additional information about it.\n"
		""},
	 { "ImageBuffer_iSize_get", _wrap_ImageBuffer_iSize_get, METH_O, "\n"
		"The size (in bytes) of the whole image.\n"
		"This value in connection with **mvIMPACT::acquire::ImageBuffer::vpData**\n"
		"is sufficient to copy the complete image without having any additional information about it.\n"
		""},
	 { "ImageBuffer_vpData_set", _wrap_ImageBuffer_vpData_set, METH_VARARGS, "\n"
		" The starting address of the image.\n"
		" This address in connection with **mvIMPACT::acquire::ImageBuffer::iSize**\n"
		" is sufficient to copy the complete image without having any additional information about it.\n"
		"\n"
		"If: (DOXYGEN_CPP_DOCUMENTATION { || DOXYGEN_C_DOCUMENTATION)\n"
		" **EXAMPLE:**\n"
		"\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     const ImageBuffer* pib = getImageBufferFromSomewhere();\n"
		"     unsigned char* pTempBuf = new unsigned char[ib.iSize];\n"
		"     memcpy( pTempBuf, pib.vpData, pIB.iSize );\n"
		"}Else if: DOXYGEN_NET_DOCUMENTATION {\n"
		"To copy this data from within a .NET environment the appropriate marshaling functions must be used!\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"Do **NOT** use this pointer in Java! It references native, unmanaged memory and cannot be copied directly into\n"
		"a piece of managed Java memory. Use **mvIMPACT::acquire::ImageBufferDesc::copy()** instead (see code below)!\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     byte[] data = new byte[pRequest.getImageSize().read()];\n"
		"     pRequest.getImageBufferDesc().copy( data );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"There are various ways to access the data captured into a request object. One way would be by using the ``ctypes`` module:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     ib = getImageBufferFromSomewhere()\n"
		"     cbuf = (ctypes.c_char * ib.iSize).from_address(int(ib.vpData))\n"
		"}\n"
		"\n"
		" Notes: \n"
		" It's not always necessary to copy the image data! Each **mvIMPACT::acquire::ImageBuffer** is an\n"
		" integral part of the **mvIMPACT::acquire::Request** object returned to the user by a call to\n"
		" the corresponding 'waitFor' function offered by the interface.\n"
		" The data in this **mvIMPACT::acquire::ImageBuffer** remains valid until the user either\n"
		" unlocks the request buffer or closes the **mvIMPACT::acquire::Device** again.\n"
		"\n"
		"\n"
		" By unlocking the **mvIMPACT::acquire::Request** the user informs the driver, that this **mvIMPACT::acquire::Request**\n"
		" and the **mvIMPACT::acquire::ImageBuffer** belonging to that **mvIMPACT::acquire::Request** is not longer needed by the\n"
		" user. The driver then queues this **mvIMPACT::acquire::Request** for capturing image data into it once\n"
		" again. However once a **mvIMPACT::acquire::Request** has been returned to the user, its **mvIMPACT::acquire::ImageBuffer**\n"
		" can't be overwritten by the driver! Therefore the user can work with, modify, store or\n"
		" copy the data safely until he unlocks the **mvIMPACT::acquire::Request** again.\n"
		""},
	 { "ImageBuffer_vpData_get", _wrap_ImageBuffer_vpData_get, METH_O, "\n"
		" The starting address of the image.\n"
		" This address in connection with **mvIMPACT::acquire::ImageBuffer::iSize**\n"
		" is sufficient to copy the complete image without having any additional information about it.\n"
		"\n"
		"If: (DOXYGEN_CPP_DOCUMENTATION { || DOXYGEN_C_DOCUMENTATION)\n"
		" **EXAMPLE:**\n"
		"\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     const ImageBuffer* pib = getImageBufferFromSomewhere();\n"
		"     unsigned char* pTempBuf = new unsigned char[ib.iSize];\n"
		"     memcpy( pTempBuf, pib.vpData, pIB.iSize );\n"
		"}Else if: DOXYGEN_NET_DOCUMENTATION {\n"
		"To copy this data from within a .NET environment the appropriate marshaling functions must be used!\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"Do **NOT** use this pointer in Java! It references native, unmanaged memory and cannot be copied directly into\n"
		"a piece of managed Java memory. Use **mvIMPACT::acquire::ImageBufferDesc::copy()** instead (see code below)!\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     byte[] data = new byte[pRequest.getImageSize().read()];\n"
		"     pRequest.getImageBufferDesc().copy( data );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"There are various ways to access the data captured into a request object. One way would be by using the ``ctypes`` module:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     ib = getImageBufferFromSomewhere()\n"
		"     cbuf = (ctypes.c_char * ib.iSize).from_address(int(ib.vpData))\n"
		"}\n"
		"\n"
		" Notes: \n"
		" It's not always necessary to copy the image data! Each **mvIMPACT::acquire::ImageBuffer** is an\n"
		" integral part of the **mvIMPACT::acquire::Request** object returned to the user by a call to\n"
		" the corresponding 'waitFor' function offered by the interface.\n"
		" The data in this **mvIMPACT::acquire::ImageBuffer** remains valid until the user either\n"
		" unlocks the request buffer or closes the **mvIMPACT::acquire::Device** again.\n"
		"\n"
		"\n"
		" By unlocking the **mvIMPACT::acquire::Request** the user informs the driver, that this **mvIMPACT::acquire::Request**\n"
		" and the **mvIMPACT::acquire::ImageBuffer** belonging to that **mvIMPACT::acquire::Request** is not longer needed by the\n"
		" user. The driver then queues this **mvIMPACT::acquire::Request** for capturing image data into it once\n"
		" again. However once a **mvIMPACT::acquire::Request** has been returned to the user, its **mvIMPACT::acquire::ImageBuffer**\n"
		" can't be overwritten by the driver! Therefore the user can work with, modify, store or\n"
		" copy the data safely until he unlocks the **mvIMPACT::acquire::Request** again.\n"
		""},
	 { "ImageBuffer_iChannelCount_set", _wrap_ImageBuffer_iChannelCount_set, METH_VARARGS, "\n"
		"The number of channels this image consists of.\n"
		"For an RGB image this value e.g. would be 3. This value defines how many\n"
		"**mvIMPACT::acquire::ChannelData** structures **mvIMPACT::acquire::ImageBuffer::pChannels**\n"
		"is pointing to once this structure has been allocated and filled with valid data.\n"
		""},
	 { "ImageBuffer_iChannelCount_get", _wrap_ImageBuffer_iChannelCount_get, METH_O, "\n"
		"The number of channels this image consists of.\n"
		"For an RGB image this value e.g. would be 3. This value defines how many\n"
		"**mvIMPACT::acquire::ChannelData** structures **mvIMPACT::acquire::ImageBuffer::pChannels**\n"
		"is pointing to once this structure has been allocated and filled with valid data.\n"
		""},
	 { "ImageBuffer_pChannels_set", _wrap_ImageBuffer_pChannels_set, METH_VARARGS, " A pointer to an array of channel specific image data."},
	 { "ImageBuffer_pChannels_get", _wrap_ImageBuffer_pChannels_get, METH_O, " A pointer to an array of channel specific image data."},
	 { "new_ImageBuffer", _wrap_new_ImageBuffer, METH_NOARGS, NULL},
	 { "delete_ImageBuffer", _wrap_delete_ImageBuffer, METH_O, NULL},
	 { "ImageBuffer_swigregister", ImageBuffer_swigregister, METH_O, NULL},
	 { "ImageBuffer_swiginit", ImageBuffer_swiginit, METH_VARARGS, NULL},
	 { "new_ImpactAcquireException", _wrap_new_ImpactAcquireException, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::ImpactAcquireException** object.\n"
		":type errorString: string\n"
		":param errorString: [in] The string representation of the error.\n"
		":type errorOrigin: string\n"
		":param errorOrigin: [in] The origin of the error (function name and line)\n"
		":type errorCode: int\n"
		":param errorCode: [in] The numerical representation of the error.\n"
		""},
	 { "delete_ImpactAcquireException", _wrap_delete_ImpactAcquireException, METH_O, NULL},
	 { "ImpactAcquireException_getErrorString", _wrap_ImpactAcquireException_getErrorString, METH_O, " Returns an error string containing information about the reason for the error."},
	 { "ImpactAcquireException_getErrorCode", _wrap_ImpactAcquireException_getErrorCode, METH_O, " Returns a unique numerical representation for this error."},
	 { "ImpactAcquireException_getErrorCodeAsString", _wrap_ImpactAcquireException_getErrorCodeAsString, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns a string representation of the error associated with the exception.\n"
		"This function will return the name of the enum of the error code.\n"
		"\n"
		"**EXAMPLE**\n"
		"\n"
		"In case of error **-2102** this function would return **mvIMPACT::acquire::DMR_DRV_ALREADY_IN_USE**, which\n"
		"is the error codes corresponding enum name.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns a string representation of a error.\n"
		"This function will return the name of the enum of the error code.\n"
		"\n"
		"**EXAMPLE**\n"
		"\n"
		"In case of error **-2102** this function would return **mvIMPACT::acquire::DMR_DRV_ALREADY_IN_USE**, which\n"
		"is the error codes corresponding enum name.\n"
		"\n"
		":type errorCode: int\n"
		":param errorCode: [in] The error code to query a string representation for.\n"
		""},
	 { "ImpactAcquireException_getErrorOrigin", _wrap_ImpactAcquireException_getErrorOrigin, METH_O, "\n"
		" Returns information about the origin of the error.\n"
		"The string returned by this function will contain the name of the function\n"
		"and the line number where the exception was raised.\n"
		""},
	 { "ImpactAcquireException_getArgs", _wrap_ImpactAcquireException_getArgs, METH_O, NULL},
	 { "ImpactAcquireException___str__", _wrap_ImpactAcquireException___str__, METH_O, NULL},
	 { "ImpactAcquireException_swigregister", ImpactAcquireException_swigregister, METH_O, NULL},
	 { "ImpactAcquireException_swiginit", ImpactAcquireException_swiginit, METH_VARARGS, NULL},
	 { "new_EDeviceManager", _wrap_new_EDeviceManager, METH_VARARGS, "\n"
		" Creates a new **mvIMPACT::acquire::EDeviceManager** object.\n"
		":type errorString: string\n"
		":param errorString: [in] The error string.\n"
		":type errorOrigin: string\n"
		":param errorOrigin: [in] The error origin.\n"
		":type errorCode: int\n"
		":param errorCode: [in] The error code.\n"
		""},
	 { "delete_EDeviceManager", _wrap_delete_EDeviceManager, METH_O, NULL},
	 { "EDeviceManager_swigregister", EDeviceManager_swigregister, METH_O, NULL},
	 { "EDeviceManager_swiginit", EDeviceManager_swiginit, METH_VARARGS, NULL},
	 { "new_EPropertyHandling", _wrap_new_EPropertyHandling, METH_VARARGS, "\n"
		" Creates a new **mvIMPACT::acquire::EPropertyHandling** object.\n"
		":type errorString: string\n"
		":param errorString: [in] The error string.\n"
		":type errorOrigin: string\n"
		":param errorOrigin: [in] The error origin.\n"
		":type errorCode: int\n"
		":param errorCode: [in] The error code.\n"
		""},
	 { "delete_EPropertyHandling", _wrap_delete_EPropertyHandling, METH_O, NULL},
	 { "EPropertyHandling_swigregister", EPropertyHandling_swigregister, METH_O, NULL},
	 { "EPropertyHandling_swiginit", EPropertyHandling_swiginit, METH_VARARGS, NULL},
	 { "EComponent_swigregister", EComponent_swigregister, METH_O, NULL},
	 { "new_ENotAList", _wrap_new_ENotAList, METH_VARARGS, NULL},
	 { "delete_ENotAList", _wrap_delete_ENotAList, METH_O, NULL},
	 { "ENotAList_swigregister", ENotAList_swigregister, METH_O, NULL},
	 { "ENotAList_swiginit", ENotAList_swiginit, METH_VARARGS, NULL},
	 { "new_ENotAProperty", _wrap_new_ENotAProperty, METH_VARARGS, NULL},
	 { "delete_ENotAProperty", _wrap_delete_ENotAProperty, METH_O, NULL},
	 { "ENotAProperty_swigregister", ENotAProperty_swigregister, METH_O, NULL},
	 { "ENotAProperty_swiginit", ENotAProperty_swiginit, METH_VARARGS, NULL},
	 { "new_ENotAMethod", _wrap_new_ENotAMethod, METH_VARARGS, NULL},
	 { "delete_ENotAMethod", _wrap_delete_ENotAMethod, METH_O, NULL},
	 { "ENotAMethod_swigregister", ENotAMethod_swigregister, METH_O, NULL},
	 { "ENotAMethod_swiginit", ENotAMethod_swiginit, METH_VARARGS, NULL},
	 { "new_ENoReadRights", _wrap_new_ENoReadRights, METH_VARARGS, NULL},
	 { "delete_ENoReadRights", _wrap_delete_ENoReadRights, METH_O, NULL},
	 { "ENoReadRights_swigregister", ENoReadRights_swigregister, METH_O, NULL},
	 { "ENoReadRights_swiginit", ENoReadRights_swiginit, METH_VARARGS, NULL},
	 { "new_ENoWriteRights", _wrap_new_ENoWriteRights, METH_VARARGS, NULL},
	 { "delete_ENoWriteRights", _wrap_delete_ENoWriteRights, METH_O, NULL},
	 { "ENoWriteRights_swigregister", ENoWriteRights_swigregister, METH_O, NULL},
	 { "ENoWriteRights_swiginit", ENoWriteRights_swiginit, METH_VARARGS, NULL},
	 { "new_ENoModifySizeRights", _wrap_new_ENoModifySizeRights, METH_VARARGS, NULL},
	 { "delete_ENoModifySizeRights", _wrap_delete_ENoModifySizeRights, METH_O, NULL},
	 { "ENoModifySizeRights_swigregister", ENoModifySizeRights_swigregister, METH_O, NULL},
	 { "ENoModifySizeRights_swiginit", ENoModifySizeRights_swiginit, METH_VARARGS, NULL},
	 { "new_EIncompatibleComponents", _wrap_new_EIncompatibleComponents, METH_VARARGS, NULL},
	 { "delete_EIncompatibleComponents", _wrap_delete_EIncompatibleComponents, METH_O, NULL},
	 { "EIncompatibleComponents_swigregister", EIncompatibleComponents_swigregister, METH_O, NULL},
	 { "EIncompatibleComponents_swiginit", EIncompatibleComponents_swiginit, METH_VARARGS, NULL},
	 { "EProperty_swigregister", EProperty_swigregister, METH_O, NULL},
	 { "new_EInvalidValue", _wrap_new_EInvalidValue, METH_VARARGS, NULL},
	 { "delete_EInvalidValue", _wrap_delete_EInvalidValue, METH_O, NULL},
	 { "EInvalidValue_swigregister", EInvalidValue_swigregister, METH_O, NULL},
	 { "EInvalidValue_swiginit", EInvalidValue_swiginit, METH_VARARGS, NULL},
	 { "new_EValIDOutOfBounds", _wrap_new_EValIDOutOfBounds, METH_VARARGS, NULL},
	 { "delete_EValIDOutOfBounds", _wrap_delete_EValIDOutOfBounds, METH_O, NULL},
	 { "EValIDOutOfBounds_swigregister", EValIDOutOfBounds_swigregister, METH_O, NULL},
	 { "EValIDOutOfBounds_swiginit", EValIDOutOfBounds_swiginit, METH_VARARGS, NULL},
	 { "new_ETranslationTableCorrupted", _wrap_new_ETranslationTableCorrupted, METH_VARARGS, NULL},
	 { "delete_ETranslationTableCorrupted", _wrap_delete_ETranslationTableCorrupted, METH_O, NULL},
	 { "ETranslationTableCorrupted_swigregister", ETranslationTableCorrupted_swigregister, METH_O, NULL},
	 { "ETranslationTableCorrupted_swiginit", ETranslationTableCorrupted_swiginit, METH_VARARGS, NULL},
	 { "new_ETranslationTableNotDefined", _wrap_new_ETranslationTableNotDefined, METH_VARARGS, NULL},
	 { "delete_ETranslationTableNotDefined", _wrap_delete_ETranslationTableNotDefined, METH_O, NULL},
	 { "ETranslationTableNotDefined_swigregister", ETranslationTableNotDefined_swigregister, METH_O, NULL},
	 { "ETranslationTableNotDefined_swiginit", ETranslationTableNotDefined_swiginit, METH_VARARGS, NULL},
	 { "new_EInvalidValueType", _wrap_new_EInvalidValueType, METH_VARARGS, NULL},
	 { "delete_EInvalidValueType", _wrap_delete_EInvalidValueType, METH_O, NULL},
	 { "EInvalidValueType_swigregister", EInvalidValueType_swigregister, METH_O, NULL},
	 { "EInvalidValueType_swiginit", EInvalidValueType_swiginit, METH_VARARGS, NULL},
	 { "new_EValTooLarge", _wrap_new_EValTooLarge, METH_VARARGS, NULL},
	 { "delete_EValTooLarge", _wrap_delete_EValTooLarge, METH_O, NULL},
	 { "EValTooLarge_swigregister", EValTooLarge_swigregister, METH_O, NULL},
	 { "EValTooLarge_swiginit", EValTooLarge_swiginit, METH_VARARGS, NULL},
	 { "new_EValTooSmall", _wrap_new_EValTooSmall, METH_VARARGS, NULL},
	 { "delete_EValTooSmall", _wrap_delete_EValTooSmall, METH_O, NULL},
	 { "EValTooSmall_swigregister", EValTooSmall_swigregister, METH_O, NULL},
	 { "EValTooSmall_swiginit", EValTooSmall_swiginit, METH_VARARGS, NULL},
	 { "new_EValidationFailed", _wrap_new_EValidationFailed, METH_VARARGS, NULL},
	 { "delete_EValidationFailed", _wrap_delete_EValidationFailed, METH_O, NULL},
	 { "EValidationFailed_swigregister", EValidationFailed_swigregister, METH_O, NULL},
	 { "EValidationFailed_swiginit", EValidationFailed_swiginit, METH_VARARGS, NULL},
	 { "EPropertyList_swigregister", EPropertyList_swigregister, METH_O, NULL},
	 { "new_EComponentNotFound", _wrap_new_EComponentNotFound, METH_VARARGS, NULL},
	 { "delete_EComponentNotFound", _wrap_delete_EComponentNotFound, METH_O, NULL},
	 { "EComponentNotFound_swigregister", EComponentNotFound_swigregister, METH_O, NULL},
	 { "EComponentNotFound_swiginit", EComponentNotFound_swiginit, METH_VARARGS, NULL},
	 { "new_EListEntryOccupied", _wrap_new_EListEntryOccupied, METH_O, NULL},
	 { "delete_EListEntryOccupied", _wrap_delete_EListEntryOccupied, METH_O, NULL},
	 { "EListEntryOccupied_swigregister", EListEntryOccupied_swigregister, METH_O, NULL},
	 { "EListEntryOccupied_swiginit", EListEntryOccupied_swiginit, METH_VARARGS, NULL},
	 { "new_EComponentIDInvalid", _wrap_new_EComponentIDInvalid, METH_O, NULL},
	 { "delete_EComponentIDInvalid", _wrap_delete_EComponentIDInvalid, METH_O, NULL},
	 { "EComponentIDInvalid_swigregister", EComponentIDInvalid_swigregister, METH_O, NULL},
	 { "EComponentIDInvalid_swiginit", EComponentIDInvalid_swiginit, METH_VARARGS, NULL},
	 { "new_EInvalidListID", _wrap_new_EInvalidListID, METH_VARARGS, NULL},
	 { "delete_EInvalidListID", _wrap_delete_EInvalidListID, METH_O, NULL},
	 { "EInvalidListID_swigregister", EInvalidListID_swigregister, METH_O, NULL},
	 { "EInvalidListID_swiginit", EInvalidListID_swiginit, METH_VARARGS, NULL},
	 { "new_ECantAccessData", _wrap_new_ECantAccessData, METH_VARARGS, NULL},
	 { "delete_ECantAccessData", _wrap_delete_ECantAccessData, METH_O, NULL},
	 { "ECantAccessData_swigregister", ECantAccessData_swigregister, METH_O, NULL},
	 { "ECantAccessData_swiginit", ECantAccessData_swiginit, METH_VARARGS, NULL},
	 { "new_ECantRegisterComponent", _wrap_new_ECantRegisterComponent, METH_VARARGS, NULL},
	 { "delete_ECantRegisterComponent", _wrap_delete_ECantRegisterComponent, METH_O, NULL},
	 { "ECantRegisterComponent_swigregister", ECantRegisterComponent_swigregister, METH_O, NULL},
	 { "ECantRegisterComponent_swiginit", ECantRegisterComponent_swiginit, METH_VARARGS, NULL},
	 { "EMethod_swigregister", EMethod_swigregister, METH_O, NULL},
	 { "new_EMethodPtrInvalid", _wrap_new_EMethodPtrInvalid, METH_VARARGS, NULL},
	 { "delete_EMethodPtrInvalid", _wrap_delete_EMethodPtrInvalid, METH_O, NULL},
	 { "EMethodPtrInvalid_swigregister", EMethodPtrInvalid_swigregister, METH_O, NULL},
	 { "EMethodPtrInvalid_swiginit", EMethodPtrInvalid_swiginit, METH_VARARGS, NULL},
	 { "new_EInvalidParameterList", _wrap_new_EInvalidParameterList, METH_VARARGS, NULL},
	 { "delete_EInvalidParameterList", _wrap_delete_EInvalidParameterList, METH_O, NULL},
	 { "EInvalidParameterList_swigregister", EInvalidParameterList_swigregister, METH_O, NULL},
	 { "EInvalidParameterList_swiginit", EInvalidParameterList_swiginit, METH_VARARGS, NULL},
	 { "new_EUnsupportedParameter", _wrap_new_EUnsupportedParameter, METH_O, NULL},
	 { "delete_EUnsupportedParameter", _wrap_delete_EUnsupportedParameter, METH_O, NULL},
	 { "EUnsupportedParameter_swigregister", EUnsupportedParameter_swigregister, METH_O, NULL},
	 { "EUnsupportedParameter_swiginit", EUnsupportedParameter_swiginit, METH_VARARGS, NULL},
	 { "new_ESizeMismatch", _wrap_new_ESizeMismatch, METH_VARARGS, NULL},
	 { "delete_ESizeMismatch", _wrap_delete_ESizeMismatch, METH_O, NULL},
	 { "ESizeMismatch_swigregister", ESizeMismatch_swigregister, METH_O, NULL},
	 { "ESizeMismatch_swiginit", ESizeMismatch_swiginit, METH_VARARGS, NULL},
	 { "new_EImplementationMissing", _wrap_new_EImplementationMissing, METH_VARARGS, NULL},
	 { "delete_EImplementationMissing", _wrap_delete_EImplementationMissing, METH_O, NULL},
	 { "EImplementationMissing_swigregister", EImplementationMissing_swigregister, METH_O, NULL},
	 { "EImplementationMissing_swiginit", EImplementationMissing_swiginit, METH_VARARGS, NULL},
	 { "new_EInvalidInputParameter", _wrap_new_EInvalidInputParameter, METH_VARARGS, NULL},
	 { "delete_EInvalidInputParameter", _wrap_delete_EInvalidInputParameter, METH_O, NULL},
	 { "EInvalidInputParameter_swigregister", EInvalidInputParameter_swigregister, METH_O, NULL},
	 { "EInvalidInputParameter_swiginit", EInvalidInputParameter_swiginit, METH_VARARGS, NULL},
	 { "new_EInputBufferTooSmall", _wrap_new_EInputBufferTooSmall, METH_O, NULL},
	 { "delete_EInputBufferTooSmall", _wrap_delete_EInputBufferTooSmall, METH_O, NULL},
	 { "EInputBufferTooSmall_swigregister", EInputBufferTooSmall_swigregister, METH_O, NULL},
	 { "EInputBufferTooSmall_swiginit", EInputBufferTooSmall_swiginit, METH_VARARGS, NULL},
	 { "new_EWrongParamCount", _wrap_new_EWrongParamCount, METH_VARARGS, NULL},
	 { "delete_EWrongParamCount", _wrap_delete_EWrongParamCount, METH_O, NULL},
	 { "EWrongParamCount_swigregister", EWrongParamCount_swigregister, METH_O, NULL},
	 { "EWrongParamCount_swiginit", EWrongParamCount_swiginit, METH_VARARGS, NULL},
	 { "new_EUnsupportedOperation", _wrap_new_EUnsupportedOperation, METH_O, NULL},
	 { "delete_EUnsupportedOperation", _wrap_delete_EUnsupportedOperation, METH_O, NULL},
	 { "EUnsupportedOperation_swigregister", EUnsupportedOperation_swigregister, METH_O, NULL},
	 { "EUnsupportedOperation_swiginit", EUnsupportedOperation_swiginit, METH_VARARGS, NULL},
	 { "new_ECantSerializeData", _wrap_new_ECantSerializeData, METH_VARARGS, NULL},
	 { "delete_ECantSerializeData", _wrap_delete_ECantSerializeData, METH_O, NULL},
	 { "ECantSerializeData_swigregister", ECantSerializeData_swigregister, METH_O, NULL},
	 { "ECantSerializeData_swiginit", ECantSerializeData_swiginit, METH_VARARGS, NULL},
	 { "new_EInvalidFileContent", _wrap_new_EInvalidFileContent, METH_VARARGS, NULL},
	 { "delete_EInvalidFileContent", _wrap_delete_EInvalidFileContent, METH_O, NULL},
	 { "EInvalidFileContent_swigregister", EInvalidFileContent_swigregister, METH_O, NULL},
	 { "EInvalidFileContent_swiginit", EInvalidFileContent_swiginit, METH_VARARGS, NULL},
	 { "new_ECantAllocateNewList", _wrap_new_ECantAllocateNewList, METH_O, NULL},
	 { "delete_ECantAllocateNewList", _wrap_delete_ECantAllocateNewList, METH_O, NULL},
	 { "ECantAllocateNewList_swigregister", ECantAllocateNewList_swigregister, METH_O, NULL},
	 { "ECantAllocateNewList_swiginit", ECantAllocateNewList_swiginit, METH_VARARGS, NULL},
	 { "ExceptionFactory_getLastErrorString", _wrap_ExceptionFactory_getLastErrorString, METH_NOARGS, "\n"
		" Returns the last error string that did occur inside the framework within the current thread.\n"
		":rtype: string\n"
		":return: The last error string that did occur inside the framework within the current thread.\n"
		""},
	 { "ExceptionFactory_raiseException", _wrap_ExceptionFactory_raiseException, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Raises an exception from an error code, its origin in terms of the function name and the line number the error did occur and an optional component handle.\n"
		":type pFunctionName: string\n"
		":param pFunctionName: [in] The name of the function this exception was raised from.\n"
		":type lineNumber: int\n"
		":param lineNumber: [in] The line number in the source this exception was raised from.\n"
		":type errorCode: int\n"
		":param errorCode: [in] The error code.\n"
		":type objectHandle: int\n"
		":param objectHandle: [in] A handle to an object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Raises an exception from an error code, its origin in terms of the function name and the line number the error did occur and an exception string.\n"
		":type pFunctionName: string\n"
		":param pFunctionName: [in] The name of the function this exception was raised from.\n"
		":type lineNumber: int\n"
		":param lineNumber: [in] The line number in the source this exception was raised from.\n"
		":type errorCode: int\n"
		":param errorCode: [in] The error code.\n"
		":type msg: string\n"
		":param msg: [in] The actual exception text.\n"
		""},
	 { "new_ExceptionFactory", _wrap_new_ExceptionFactory, METH_NOARGS, NULL},
	 { "delete_ExceptionFactory", _wrap_delete_ExceptionFactory, METH_O, NULL},
	 { "ExceptionFactory_swigregister", ExceptionFactory_swigregister, METH_O, NULL},
	 { "ExceptionFactory_swiginit", ExceptionFactory_swiginit, METH_VARARGS, NULL},
	 { "delete_ComponentAccess", _wrap_delete_ComponentAccess, METH_O, NULL},
	 { "new_ComponentAccess", _wrap_new_ComponentAccess, METH_VARARGS, NULL},
	 { "ComponentAccess_changedCounter", _wrap_ComponentAccess_changedCounter, METH_O, "\n"
		" Returns the current changed counter for the component referenced by this object.\n"
		" This changed counter is incremented internally each time the component is modified.\n"
		" To check if this component has been modified since the last time, this check has been\n"
		" performed, keep track of the last return value of this function and compare\n"
		" it with the new value. This can be helpful e.g. to keep a GUI up to date. The value returned\n"
		" by this function will always be larger than or equal to the value returned by\n"
		" **mvIMPACT::acquire::ComponentAccess::changedCounterAttr** (except in case of a\n"
		" wrap around) when called at the same time for the same object as it's always incremented\n"
		" when the component has been modified in\n"
		" any way while the latter one will only be incremented if the attributes (e.g. the\n"
		" flags) but **NOT** if e.g. the value(s) of a property has been modified.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     //-----------------------------------------------------------------------------\n"
		"     struct ComponentRef\n"
		"     //-----------------------------------------------------------------------------\n"
		"     {\n"
		"       mvIMPACT::acquire::Component c_;\n"
		"       unsigned int lastChangedCount_;\n"
		"       ComponentRef( mvIMPACT::acquire::Component c ) : c_( c ), lastChangedCount_( 0 ) {}\n"
		"     };\n"
		"\n"
		"     //-----------------------------------------------------------------------------\n"
		"     void fn( ComponentRef cr )\n"
		"     //-----------------------------------------------------------------------------\n"
		"     {\n"
		"       if( cr.c_.isValid() )\n"
		"       {\n"
		"         const unsigned int currentChangedCount = cr.c_.changedCounter();\n"
		"         if( currentChangedCount != cr.lastChangedCount_ )\n"
		"         {\n"
		"           // something has happened since the last check!\n"
		"           doWhatNeedsToBeDone();\n"
		"           // and remember the current changed counter\n"
		"           cr.lastChangedCount_ = currentChangedCount;\n"
		"         }\n"
		"       }\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     import mvIMPACT.acquire.*;\n"
		"\n"
		"     //-----------------------------------------------------------------------------\n"
		"     public class ComponentRef\n"
		"     //-----------------------------------------------------------------------------\n"
		"     {\n"
		"       private Component c_;\n"
		"       private long lastChangedCount_;\n"
		"       public ComponentRef( Component c ) : c_( c ), lastChangedCount_( 0 ) {}\n"
		"       public Component getComponent()\n"
		"       {\n"
		"         return c_;\n"
		"       }\n"
		"       public long getLastChangedCounter()\n"
		"       {\n"
		"         return lastChangedCount_;\n"
		"       }\n"
		"       public void setLastChangedCounter( long changedCounter )\n"
		"       {\n"
		"         lastChangedCount_ = lastChangedCount;\n"
		"       }\n"
		"     }\n"
		"\n"
		"     // ...more code, class definition etc.\n"
		"\n"
		"     //-----------------------------------------------------------------------------\n"
		"     public static void fn( ComponentRef cr )\n"
		"     //-----------------------------------------------------------------------------\n"
		"     {\n"
		"       if( cr.c_.isValid() )\n"
		"       {\n"
		"         final long currentChangedCount = cr.getComponent().changedCounter();\n"
		"         if( currentChangedCount != cr.getLastChangedCounter() )\n"
		"         {\n"
		"           // something has happened since the last check!\n"
		"           doWhatNeedsToBeDone();\n"
		"           // and remember the current changed counter\n"
		"           cr.setLastChangedCounter( currentChangedCount );\n"
		"         }\n"
		"       }\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     class ComponentRef\n"
		"       def __init__(self, c):\n"
		"         self.c_ = c\n"
		"         self.lastChangedCount_ = 0\n"
		"\n"
		"     def fn(cr):\n"
		"       if cr.c_.isValid:\n"
		"         currentChangedCount = cr.c_.changedCounter()\n"
		"         if currentChangedCount != cr.lastChangedCount_:\n"
		"           # something has happened since the last check!\n"
		"           doWhatNeedsToBeDone()\n"
		"           # and remember the current changed counter\n"
		"           cr.lastChangedCount_ = currentChangedCount\n"
		"}\n"
		"\n"
		":rtype: int\n"
		":return: The current changed counter of this object.\n"
		""},
	 { "ComponentAccess_changedCounterAttr", _wrap_ComponentAccess_changedCounterAttr, METH_O, "\n"
		" Returns the current attribute changed counter for the component referenced by this object.\n"
		"This changed counter is incremented internally each time the components attributes have been modified.\n"
		"To check if this components attributes have been modified since the last time, this check has been\n"
		"performed, keep track of the last return value of this function and compare\n"
		"it with the new value. This can be helpful e.g. to keep a GUI up to date.\n"
		"\n"
		"Notes: \n"
		"Attributes changes are e.g. a modification to a property's translation dictionary,\n"
		"but **NOT** a property's value. Because of this the value returned by this function\n"
		"will always be less or equal than the value returned by the function\n"
		"**mvIMPACT::acquire::ComponentAccess::changedCounter** (except in case of a\n"
		"wrap around) when called at the same time for the same object.\n"
		"See also: **mvIMPACT::acquire::ComponentAccess::changedCounter**\n"
		":rtype: int\n"
		":return: The current attributes changed counter of this object.\n"
		""},
	 { "ComponentAccess_hObj", _wrap_ComponentAccess_hObj, METH_O, "\n"
		"Returns a unique identifier for the component referenced by this object.\n"
		":rtype: int\n"
		":return: A unique identifier for the component referenced by this object.\n"
		""},
	 { "ComponentAccess_name", _wrap_ComponentAccess_name, METH_O, "\n"
		"Returns the name of the component referenced by this object.\n"
		":rtype: string\n"
		":return: The name of the component referenced by this object.\n"
		""},
	 { "ComponentAccess_displayName", _wrap_ComponentAccess_displayName, METH_O, "\n"
		" Returns the display name of the component referenced by this object.\n"
		"\n"
		"Since: 1.11.20\n"
		"\n"
		" :rtype: string\n"
		" :return: The display name of the component referenced by this object. This might be an empty string if no display name has been specified.\n"
		""},
	 { "ComponentAccess_swigregister", ComponentAccess_swigregister, METH_O, NULL},
	 { "ComponentAccess_swiginit", ComponentAccess_swiginit, METH_VARARGS, NULL},
	 { "new_Component", _wrap_new_Component, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new access object to a driver object.\n"
		":type hObj: int\n"
		":param hObj: [in] A valid handle to a component object\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new unbound access object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::Component** from an existing one.\n"
		":type src: :py:class:`Component`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::Component** object, this object shall be created from\n"
		""},
	 { "Component_firstSibling", _wrap_Component_firstSibling, METH_O, "\n"
		"Moves to the first sibling(the first feature in the current list of features).\n"
		":rtype: :py:class:`Component`\n"
		":return: A new **mvIMPACT::acquire::Component** object\n"
		""},
	 { "Component_lastSibling", _wrap_Component_lastSibling, METH_O, "\n"
		" Moves to the last sibling(the last feature in the current list of features).\n"
		"\n"
		"Since: 1.10.64\n"
		"\n"
		" :rtype: :py:class:`Component`\n"
		" :return: A new **mvIMPACT::acquire::Component** object\n"
		""},
	 { "Component_nextSibling", _wrap_Component_nextSibling, METH_O, "\n"
		"Moves to the next sibling(the next feature in the current list of features).\n"
		":rtype: :py:class:`Component`\n"
		":return: A new **mvIMPACT::acquire::Component** object\n"
		""},
	 { "Component_firstChild", _wrap_Component_firstChild, METH_O, "\n"
		" Moves to the first child of this component(moves down one level).\n"
		"Calling this function will only succeed, if the current **mvIMPACT::acquire::Component**\n"
		"references a list.\n"
		"\n"
		":rtype: :py:class:`Component`\n"
		":return: A new **mvIMPACT::acquire::Component** object\n"
		""},
	 { "Component_parent", _wrap_Component_parent, METH_O, "\n"
		"Moves to the parent of this component(moves up one level).\n"
		":rtype: :py:class:`Component`\n"
		":return: A new **mvIMPACT::acquire::Component** object\n"
		""},
	 { "Component_docString", _wrap_Component_docString, METH_O, "\n"
		"Returns a string containing general information about the component referenced by this object.\n"
		":rtype: string\n"
		":return: A string containing general information about the component referenced by this object.\n"
		""},
	 { "Component_flags", _wrap_Component_flags, METH_O, "\n"
		"Returns the flags associated with this component.\n"
		":rtype: int\n"
		":return: The flags associated with this component.\n"
		""},
	 { "Component_flagsAsString", _wrap_Component_flagsAsString, METH_VARARGS, "\n"
		" Returns the flags associated with this component as a string.\n"
		" :rtype: string\n"
		" :return: The flags associated with this component as a string.\n"
		"\n"
		":type separator: string\n"
		":param separator: [in] A user definable string to separate the individual flags. The default value is ' | ' resulting in the string to look e.g. like this: **'cfWriteAccess | cfReadAccess'**\n"
		""},
	 { "Component_getIsDefault", _wrap_Component_getIsDefault, METH_O, "\n"
		"Checks if this component is currently referencing the default for this component.\n"
		"This function will return true only for derived components that have not been modified.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the component is currently set to its default value\n"
		"    - false otherwise.\n"
		""},
	 { "Component_getIsList", _wrap_Component_getIsList, METH_O, "\n"
		"Checks if this component is of type **mvIMPACT::acquire::ComponentList**.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the component references a list\n"
		"    - false otherwise\n"
		""},
	 { "Component_getIsMeth", _wrap_Component_getIsMeth, METH_O, "\n"
		"Checks if this component is of type **mvIMPACT::acquire::Method**.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the component references a method\n"
		"    - false otherwise\n"
		""},
	 { "Component_getIsProp", _wrap_Component_getIsProp, METH_O, "\n"
		"Checks if this component is of type **mvIMPACT::acquire::Property** or a derived type.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the component references a property\n"
		"    - false otherwise\n"
		""},
	 { "Component_getIsValid", _wrap_Component_getIsValid, METH_O, "\n"
		"Checks if the internal component referenced by this object is still valid.\n"
		"This function can be used to verify whether a referenced component\n"
		"is still valid or not. When e.g. referencing a driver property after\n"
		"**mvIMPACT::acquire::Device::close** has been called this function would return false.\n"
		"Calling any other function that tries to access the referenced component\n"
		"in that case would raise an exception.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if this object currently references a valid component\n"
		"    - false otherwise.\n"
		""},
	 { "Component_getIsVisible", _wrap_Component_getIsVisible, METH_O, "\n"
		" Checks if the component is currently shadowed due to a settings made elsewhere or not.\n"
		"Settings applied to certain components might affect the behaviour of others. For example\n"
		"an activated automatic gain control might shadow the value written to the\n"
		"gain property by the user as the gain is calculated internally. In order to\n"
		"check if modifying the actual component will affect the behaviour of the\n"
		"system this function may be used. When it returns *true*, the **mvIMPACT::acquire::Component**\n"
		"will have an impact on the system, if *false* is returned, the feature might be\n"
		"modified, but this will currently NOT influence the acquisition process or the overall behaviour\n"
		"of the device or driver.\n"
		"\n"
		"This is what is called visibility. The user still might modify or read the\n"
		"current **mvIMPACT::acquire::Component** when it's not visible however the actual data will\n"
		"be used only if the **Component** is visible (**mvIMPACT::acquire::cfInvisible**\n"
		"must **NOT** be set).\n"
		"\n"
		"The visibility of a **mvIMPACT::acquire::Component** object will change only if other\n"
		"**mvIMPACT::acquire::Component** objects are modified and **NEVER** when a program\n"
		"runs but does not change any **mvIMPACT::acquire::Component**.\n"
		""},
	 { "Component_getIsWriteable", _wrap_Component_getIsWriteable, METH_O, "\n"
		"Checks if the caller has write/modify access to the component.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the caller is allowed to call write/modify operation for this component.\n"
		"    - false otherwise.\n"
		""},
	 { "Component_restoreDefault", _wrap_Component_restoreDefault, METH_O, "\n"
		" Restores the default for the referenced component.\n"
		"Calling this function will restore the default value for the\n"
		"component referenced by this object.\n"
		"\n"
		"If this function is called for an object of type **mvIMPACT::acquire::ComponentList**\n"
		"every component in that list is restored to the default value.\n"
		"\n"
		"Notes: The caller must have the right to modify the component. Otherwise\n"
		"an exception will be thrown.\n"
		"\n"
		":rtype: :py:class:`Component`\n"
		":return: A const reference to the component.\n"
		""},
	 { "Component_type", _wrap_Component_type, METH_O, "\n"
		"Returns the type of the referenced component.\n"
		":rtype: int\n"
		":return: The type of the referenced component.\n"
		""},
	 { "Component_getType", _wrap_Component_getType, METH_O, "\n"
		" Returns the type of the component referenced by *hObj*.\n"
		" :rtype: int\n"
		" :return: The type of the component referenced by *hObj*.\n"
		"\n"
		":type hObj: int\n"
		":param hObj: [in] The component the type shall be retrieved for\n"
		""},
	 { "Component_typeAsString", _wrap_Component_typeAsString, METH_O, "\n"
		"Returns the type of the referenced component as a string.\n"
		":rtype: string\n"
		":return: The type of the referenced component as a string.\n"
		""},
	 { "Component_visibility", _wrap_Component_visibility, METH_O, "\n"
		" Returns the recommended visibility for this component.\n"
		"The visibility can be used e.g. to develop a GUI that displays a\n"
		"crucial subset of features only.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TComponentVisibility**.\n"
		":rtype: int\n"
		":return: The recommended visibility for this component.\n"
		""},
	 { "Component_visibilityAsString", _wrap_Component_visibilityAsString, METH_O, "\n"
		"Returns the recommended visibility of the referenced component as a string.\n"
		":rtype: string\n"
		":return: The recommended visibility of the referenced component as a string.\n"
		""},
	 { "Component_getVisibilityAsString", _wrap_Component_getVisibilityAsString, METH_O, "\n"
		" Returns the recommended visibility converted to a string.\n"
		" :rtype: string\n"
		" :return: The recommended visibility converted to a string.\n"
		"\n"
		":type visibility: int\n"
		":param visibility: [in] The visibility to query the string representation for\n"
		""},
	 { "Component_representation", _wrap_Component_representation, METH_O, "\n"
		" Returns the recommended representation for this component.\n"
		"The representation can be used e.g. to develop a GUI that creates convenient controls\n"
		" for certain features.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TComponentRepresentation**.\n"
		"\n"
		" Since: 2.14.0\n"
		"\n"
		":rtype: int\n"
		":return: The recommended representation for this component.\n"
		""},
	 { "Component_representationAsString", _wrap_Component_representationAsString, METH_O, "\n"
		"Returns the recommended representation of the referenced component as a string.\n"
		"\n"
		"Since: 2.14.0\n"
		"\n"
		":rtype: string\n"
		":return: The recommended representation of the referenced component as a string.\n"
		""},
	 { "Component_getRepresentationAsString", _wrap_Component_getRepresentationAsString, METH_O, "\n"
		" Returns the recommended representation converted to a string.\n"
		"\n"
		" Since: 2.14.0\n"
		"\n"
		" :rtype: string\n"
		" :return: The recommended representation converted to a string.\n"
		"\n"
		":type representation: int\n"
		":param representation: [in] The representation to query the string representation for\n"
		""},
	 { "Component_selectedFeatureCount", _wrap_Component_selectedFeatureCount, METH_O, "\n"
		" Returns the number of features selected by the current one.\n"
		"See also: \n"
		"**mvIMPACT::acquire::Component::selectedFeatures**,\n"
		"\n"
		"**mvIMPACT::acquire::Component::selectedFeature**\n"
		"\n"
		"Since: 1.11.20\n"
		"\n"
		":rtype: int\n"
		":return: The number of features selected by the current one.\n"
		""},
	 { "Component_selectingFeatureCount", _wrap_Component_selectingFeatureCount, METH_O, "\n"
		" Returns the number of features selecting the current one.\n"
		"See also: \n"
		"**mvIMPACT::acquire::Component::selectingFeatures**,\n"
		"\n"
		"**mvIMPACT::acquire::Component::selectingFeature**\n"
		"\n"
		"Since: 1.11.20\n"
		"\n"
		":rtype: int\n"
		":return: The number of features selecting the current one.\n"
		""},
	 { "Component_selectedFeatures", _wrap_Component_selectedFeatures, METH_VARARGS, "\n"
		" Retrieves the list of components that are selected by the current one.\n"
		"This function retrieves the list of components that are selected by\n"
		"the current one. This information is mainly useful for GUI applications that want to arrange\n"
		"features in a way that dependencies between features can easily been spotted.\n"
		"\n"
		"When a component 'selects' other components, this indicates that selected components may change whenever\n"
		"the selecting component changes. An example for a selector might be a property defining the index within\n"
		"a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties\n"
		"*LUTIndex* and *LUTValue* then changing *LUTIndex* will invalidate and possibly change *LUTValue*.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::Component::selectedFeatureCount**,\n"
		"\n"
		"**mvIMPACT::acquire::Component::selectedFeature**\n"
		"\n"
		"Since: 1.11.20\n"
		"\n"
		":rtype: int\n"
		":return: The number of features selected by the current one.\n"
		"\n"
		":type v: std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > >\n"
		":param v: [out] An array that will retrieve the list of components that are selected by the current one.\n"
		""},
	 { "Component_selectingFeatures", _wrap_Component_selectingFeatures, METH_VARARGS, "\n"
		" Retrieves the list of components that are selecting the current one.\n"
		"This function retrieves the list of components that are selecting\n"
		"the current one. This information is mainly useful for GUI applications that want to arrange\n"
		"features in a way that dependencies between features can easily been spotted.\n"
		"\n"
		"When a component 'selects' other components, this indicates that selected components may change whenever\n"
		"the selecting component changes. An example for a selector might be a property defining the index within\n"
		"a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties\n"
		"*LUTIndex* and *LUTValue* then changing *LUTIndex* will invalidate and possibly change *LUTValue*.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::Component::selectingFeatureCount**,\n"
		"\n"
		"**mvIMPACT::acquire::Component::selectingFeature**\n"
		"\n"
		"Since: 1.11.20\n"
		"\n"
		":rtype: int\n"
		":return: The number of features selecting the current one.\n"
		"\n"
		":type v: std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > >\n"
		":param v: [out] An array that will retrieve the list of components that are selecting the current one.\n"
		""},
	 { "Component_selectedFeature", _wrap_Component_selectedFeature, METH_VARARGS, "\n"
		" Retrieves a component that is selected by the current one.\n"
		"This function retrieves a component that is selected by the current one.\n"
		"This information is mainly useful for GUI applications that want to arrange\n"
		"features in a way that dependencies between features can easily been spotted.\n"
		"\n"
		"When a component 'selects' other components, this indicates that selected components may change whenever\n"
		"the selecting component changes. An example for a selector might be a property defining the index within\n"
		"a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties\n"
		"*LUTIndex* and *LUTValue* then changing *LUTIndex* will invalidate and possibly change *LUTValue*.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::Component::selectedFeatures** to obtain this\n"
		"information.\n"
		"}\n"
		"\n"
		"To find out how many **mvIMPACT::acquire::Component** objects are selected by the current one call\n"
		"**mvIMPACT::acquire::Component::selectedFeatureCount**. This value minus 1 will also be the\n"
		"max. value for *index*.\n"
		"See also: \n"
		"**mvIMPACT::acquire::Component::selectedFeatureCount**,\n"
		"\n"
		"**mvIMPACT::acquire::Component::selectedFeatures**\n"
		"\n"
		"Since: 1.11.20\n"
		"\n"
		":rtype: :py:class:`Component`\n"
		":return: A **mvIMPACT::acquire::Component** that is selected by the current one.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index for the component to query.\n"
		""},
	 { "Component_selectingFeature", _wrap_Component_selectingFeature, METH_VARARGS, "\n"
		" Retrieves a component that is selecting the current one.\n"
		"This function retrieves a component that is selecting the current one.\n"
		"This information is mainly useful for GUI applications that want to arrange\n"
		"features in a way that dependencies between features can easily been spotted.\n"
		"\n"
		"When a component 'selects' other components, this indicates that selected components may change whenever\n"
		"the selecting component changes. An example for a selector might be a property defining the index within\n"
		"a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties\n"
		"*LUTIndex* and *LUTValue* then changing *LUTIndex* will invalidate and possibly change *LUTValue*.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::Component::selectingFeatures** to obtain this\n"
		"information.\n"
		"}\n"
		"\n"
		"To find out how many **mvIMPACT::acquire::Component** objects are selecting the current one call\n"
		"**mvIMPACT::acquire::Component::selectingFeatureCount**. This value minus 1 will also be the\n"
		"max. value for *index*.\n"
		"See also: \n"
		"**mvIMPACT::acquire::Component::selectingFeatureCount**,\n"
		"\n"
		"**mvIMPACT::acquire::Component::selectingFeatures**\n"
		"\n"
		"Since: 1.11.20\n"
		"\n"
		":rtype: :py:class:`Component`\n"
		":return: A **mvIMPACT::acquire::Component** that is selecting the current one.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index for the component to query.\n"
		""},
	 { "delete_Component", _wrap_delete_Component, METH_O, NULL},
	 { "Component_swigregister", Component_swigregister, METH_O, NULL},
	 { "Component_swiginit", Component_swiginit, METH_VARARGS, NULL},
	 { "new_ComponentCallback", _wrap_new_ComponentCallback, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Creates a new **mvIMPACT::acquire::ComponentCallback** instance.\n"
		":type pUserData: void\n"
		":param pUserData: [in] A pointer to user specific data bound to this callback. This data will be passed back to the user whenever the callback function gets executed and can be used to attach custom data to the callback function.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Copy constructor.\n"
		"Creates a new object from an existing device object. Keep in mind that this new object\n"
		"will provide access to the very same objects. This constructor\n"
		"is only provided for internal reference counting to guarantee correct operation of the\n"
		"objects of this class under all platforms and languages.\n"
		""},
	 { "delete_ComponentCallback", _wrap_delete_ComponentCallback, METH_O, "\n"
		" Class destructor.\n"
		"This will automatically unregister all components still referencing this callback and will\n"
		"free all internal resources.\n"
		""},
	 { "ComponentCallback_isComponentRegistered", _wrap_ComponentCallback_isComponentRegistered, METH_VARARGS, "\n"
		" Checks if a component is currently registered for this callback or not.\n"
		":rtype: boolean\n"
		":return: \n"
		"     - true if the component currently is registered for this callback\n"
		"     - false otherwise\n"
		"\n"
		":type c: :py:class:`Component`\n"
		":param c: [in] The component that shall be tested against this callback\n"
		""},
	 { "ComponentCallback_registerComponent", _wrap_ComponentCallback_registerComponent, METH_VARARGS, "\n"
		" Registers a component for this callback.\n"
		":rtype: boolean\n"
		":return: \n"
		"     - true if the component could be registered successfully for this callback.\n"
		"     - false otherwise\n"
		"\n"
		":type c: :py:class:`Component`\n"
		":param c: [in] The component to register for this callback\n"
		""},
	 { "ComponentCallback_unregisterComponent", _wrap_ComponentCallback_unregisterComponent, METH_VARARGS, "\n"
		" Unregisters a component for this callback.\n"
		":rtype: boolean\n"
		":return: \n"
		"     - true if the component could be unregistered successfully for this callback.\n"
		"     - false otherwise\n"
		"\n"
		":type c: :py:class:`Component`\n"
		":param c: [in] The component to unregister from this callback\n"
		""},
	 { "ComponentCallback_execute", _wrap_ComponentCallback_execute, METH_VARARGS, "\n"
		" The callback function.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		"\n"
		"Notes: \n"
		"Please note that this function will be executed within the thread context that is **causing** this callback,\n"
		"thus by any thread belonging to the internal device driver instance. There is a high chance that this is\n"
		"a different thread than any known to by the application, thus appropriate mechanisms to ensure\n"
		"correct execution must be implemented by an application(e.g. GUI applications might send an\n"
		"event to the main thread instead of directly accessing GUI elements from here).\n"
		"\n"
		"As each device driver instance internally creates multiple threads and since components can be modified by the\n"
		"driver framework from any of these threads, the thread context might in fact be different each time\n"
		"this function gets called. Accessing data from objects that are inherited from **mvIMPACT::acquire::Component** is\n"
		"thread safe so e.g. property values can be read out in parallel securely!\n"
		"However this 'execute' in a worst case (when several components have been registered to a single callback) might in\n"
		"fact be called in parallel so everything that happens in here should be designed accordingly!\n"
		"\n"
		"\n"
		"It is **NOT** recommended to do time consuming stuff here! This function should be considered as something like an\n"
		"interrupt instead: Just take a note about what did just happen and leave. The calling thread will block until this\n"
		"function does return which might have all sorts of consequences if this takes a lot of time. In the worst case\n"
		"e.g. image data might get lost!\n"
		"\n"
		"**GenICam** **event** **specific**:\n"
		"When dealing with GenICam device events from a single device only within this callback\n"
		"due to the internal design it is guaranteed that this callback will NOT be executed in parallel\n"
		"since the device events will be received sequentially and will always be reported by the same\n"
		"(device driver instance related) thread! So when e.g. registering for changes to the following\n"
		"properties:\n"
		"- mvIMPACT::acquire::GenICam::EventControl::eventLine4RisingEdgeTimestamp\n"
		"- mvIMPACT::acquire::GenICam::EventControl::eventLine5RisingEdgeTimestamp\n"
		"- mvIMPACT::acquire::GenICam::EventControl::eventExposureEndTimestamp\n"
		"for a single device only then the following things are guaranteed:\n"
		"- The thread context used by the **mvIMPACT::acquire::ComponentCallback::execute** function will always be the same until the device is either closed or the connection is lost e.g. due to a reboot\n"
		"- **mvIMPACT::acquire::ComponentCallback::execute** function will **NOT** be called concurrently\n"
		"- The event property changes will be reported in the same order as generated by the device\n"
		"\n"
		":type c: :py:class:`Component`\n"
		":param c: [in] The component that did cause the callback to be executed\n"
		":type pUserData: void\n"
		":param pUserData: [in] A pointer to user specific data that was bound to this callback instance upon construction\n"
		""},
	 { "disown_ComponentCallback", _wrap_disown_ComponentCallback, METH_O, NULL},
	 { "ComponentCallback_swigregister", ComponentCallback_swigregister, METH_O, NULL},
	 { "ComponentCallback_swiginit", ComponentCallback_swiginit, METH_VARARGS, NULL},
	 { "new_ComponentLocatorBase", _wrap_new_ComponentLocatorBase, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound locator.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new bound to the specified base list locator.\n"
		":type baselist: int\n"
		":param baselist: [in] A unique identifier to the base list from where to start to search for the search base.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new locator and searches the search base list.\n"
		":type baselist: int\n"
		":param baselist: [in] A unique identifier to the base list from where to start to search for the search base.\n"
		":type pathToSearchBase: string\n"
		":param pathToSearchBase: [in] The name or path ('/' separated) to the search base.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Constructs a new **mvIMPACT::acquire::ComponentLocatorBase** from an existing one.\n"
		":type src: :py:class:`ComponentLocatorBase`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::ComponentLocatorBase** object, this object shall be created from\n"
		""},
	 { "ComponentLocatorBase_bindComponent", _wrap_ComponentLocatorBase_bindComponent, METH_VARARGS, "\n"
		" Binds an access object to an internal driver object.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if successful\n"
		"    - false otherwise. In case false is returned by this function the component could not\n"
		"    be bound, which means subsequent calls using *access* will fail or throw an exception.\n"
		"\n"
		":type access: :py:class:`Component`\n"
		":param access: [in,out] The access object to bind to the driver object.\n"
		":type name: string\n"
		":param name: [in] The path and/or name of the object to be located.\n"
		":type searchMode: int\n"
		":param searchMode: [in] Specifies how and what to search for. Valid flags(these flags can be combined using the '|' operator) for this parameter are: - smIgnoreLists - smIgnoreMethods - smIgnoreProperties\n"
		":type maxSearchDepth: int\n"
		":param maxSearchDepth: [in] The maximum depth (in lists) where to search for the component. By e.g. setting this value to 2, the current list and all its sub lists will be searched for the object, but no sublists of sub lists. -1 will search in ALL sub lists.\n"
		""},
	 { "ComponentLocatorBase_bindSearchBase", _wrap_ComponentLocatorBase_bindSearchBase, METH_VARARGS, "\n"
		" Assign a new search base to the locator.\n"
		" This new search base will be searched starting from the base list specified.\n"
		" :rtype: int\n"
		" :return: The unique identifier of the new search base.\n"
		"\n"
		":type baselist: int\n"
		":param baselist: [in] A unique identifier for the base list used to start searching the search base.\n"
		":type pathToSearchBase: string\n"
		":param pathToSearchBase: [in] The name or path to the search base.\n"
		""},
	 { "ComponentLocatorBase_findComponent", _wrap_ComponentLocatorBase_findComponent, METH_VARARGS, "\n"
		" Tries to locate a certain component in a hierarchy of components.\n"
		" :rtype: int\n"
		" :return: A unique identifier to the component if found or **mvIMPACT::acquire::INVALID_ID** if the component couldn't\n"
		"     be found.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The path and/or name of the object to be located.\n"
		":type searchMode: int\n"
		":param searchMode: [in] Specifies how and what to search for. Valid flags(these flags can be combined using the '|' operator) for this parameter are: - smIgnoreLists - smIgnoreMethods - smIgnoreProperties\n"
		":type maxSearchDepth: int\n"
		":param maxSearchDepth: [in] The maximum depth (in lists) where to search for the component. By e.g. setting this value to 2, the current list and all its sub lists will be searched for the object, but no sublists of sub lists. -1 will search in ALL sub lists.\n"
		""},
	 { "ComponentLocatorBase_searchbase_id", _wrap_ComponentLocatorBase_searchbase_id, METH_O, "\n"
		"Returns the unique identifier of the base list from where to start searching for a component.\n"
		":rtype: int\n"
		":return: The unique identifier of the base list from where searching for a component will start currently.\n"
		""},
	 { "delete_ComponentLocatorBase", _wrap_delete_ComponentLocatorBase, METH_O, NULL},
	 { "ComponentLocatorBase_swigregister", ComponentLocatorBase_swigregister, METH_O, NULL},
	 { "ComponentLocatorBase_swiginit", ComponentLocatorBase_swiginit, METH_VARARGS, NULL},
	 { "new_ComponentLocator", _wrap_new_ComponentLocator, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound locator.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new bound to the specified base list locator.\n"
		":type baselist: int\n"
		":param baselist: [in] A unique identifier to the base list from where to start to search for the search base.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new locator and searches the search base list.\n"
		":type baselist: int\n"
		":param baselist: [in] A unique identifier to the base list from where to start to search for the search base.\n"
		":type pathToSearchBase: string\n"
		":param pathToSearchBase: [in] The name or path ('/' separated) to the search base.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Constructs a new **mvIMPACT::acquire::ComponentLocator** from an existing one.\n"
		":type src: :py:class:`ComponentLocator`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::ComponentLocator** object, this object shall be created from\n"
		""},
	 { "delete_ComponentLocator", _wrap_delete_ComponentLocator, METH_O, NULL},
	 { "ComponentLocator_swigregister", ComponentLocator_swigregister, METH_O, NULL},
	 { "ComponentLocator_swiginit", ComponentLocator_swiginit, METH_VARARGS, NULL},
	 { "new_ComponentList", _wrap_new_ComponentList, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new **mvIMPACT::acquire::ComponentList** object.\n"
		":type hList: int\n"
		":param hList: [in] A valid handle to a list object\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::ComponentList** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::ComponentList** from an existing one.\n"
		":type src: :py:class:`ComponentList`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::ComponentList** object, this object shall be created from\n"
		""},
	 { "ComponentList_size", _wrap_ComponentList_size, METH_O, "\n"
		"Returns The number of valid component entries in the referenced list.\n"
		":rtype: int\n"
		":return: The number of valid component entries in the referenced list.\n"
		""},
	 { "ComponentList_contentDescriptor", _wrap_ComponentList_contentDescriptor, METH_O, "\n"
		"Returns a string containing information about what's in this list.\n"
		"This string might not be defined by every list but in any case this function\n"
		"will return a valid string. However this string might be empty.\n"
		""},
	 { "delete_ComponentList", _wrap_delete_ComponentList, METH_O, NULL},
	 { "ComponentList_swigregister", ComponentList_swigregister, METH_O, NULL},
	 { "ComponentList_swiginit", ComponentList_swiginit, METH_VARARGS, NULL},
	 { "new_Method", _wrap_new_Method, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new **mvIMPACT::acquire::Method** object.\n"
		":type hMeth: int\n"
		":param hMeth: [in] A valid handle to method object\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::Method** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::Method** from an existing one.\n"
		":type src: :py:class:`Method`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::Method** object, this object shall be created from\n"
		""},
	 { "Method_call", _wrap_Method_call, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Calls an underlying driver function.\n"
		"This function can be used to call any driver function which is registered\n"
		"for the device it is called for. To call a function successfully the parameters\n"
		"passed to the function must match the parameters expected by the function.\n"
		"\n"
		"The parameters are passed as a list of strings.\n"
		"\n"
		"To find out what kind of parameters are expected by the function use\n"
		"the function **mvIMPACT::acquire::Method::paramList()**.\n"
		"\n"
		"floating point values can be passed either with a '.' or a ',' acting as the\n"
		"decimal point.\n"
		"\n"
		"'empty' strings can be passed as a single underline('_').rs.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    // call a function expecting a string and a float\n"
		"    vectorstring params;\n"
		"    params.push_back( \"stringParam\" );\n"
		"    params.push_back( \"3.14\" );\n"
		"    meth.call( params );\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    // call a function expecting a string and a float\n"
		"    ArrayListString list = new ArrayListString();\n"
		"    list.add( \"stringParam\" );\n"
		"    list.add( \"3.14\" );\n"
		"    StringVector params = new StringVector( list );\n"
		"    meth.call( params );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    # call a function expecting a string and a float\n"
		"    params = []\n"
		"    params.append(\"stringParam\")\n"
		"    params.append(\"3.14\")\n"
		"    meth.call(params)\n"
		"}\n"
		":rtype: int\n"
		":return: An integer value. For a typical function that is part of the driver SDK this integer value will be\n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type params: std::vector< std::string,std::allocator< std::string > >\n"
		":param params: [in] The parameters to be passed to the function as a list of strings\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Calls an underlying driver function.\n"
		"This function can be used to call any driver function which is registered\n"
		"for the device it is called for. To call a function successfully the parameters\n"
		"passed to the function must match the parameters expected by the function.\n"
		"\n"
		"All parameters are passed as a single string, which is parsed with respect to the\n"
		"given delimiter characters internally.\n"
		"\n"
		"To find out what kind of parameters are expected by the function use\n"
		"the function **mvIMPACT::acquire::Method::paramList()**.\n"
		"\n"
		"floating point values can be passed either with a '.' or a ',' acting as the\n"
		"decimal point.\n"
		"\n"
		"'empty' strings can be passed as a single underline('_').\n"
		"\n"
		"\n"
		"The characters '.', ',' and '_' can't be used as delimiters.\n"
		"\n"
		"If: (DOXYGEN_CPP_DOCUMENTATION { || DOXYGEN_JAVA_DOCUMENTATION)\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    // call a function expecting a string and a float\n"
		"    // value parameters separated by spaces\n"
		"    meth.call( \"stringParam 3,14\" );\n"
		"    // call of a function expecting 2 integers an a string\n"
		"    // where an empty string shall be passed\n"
		"    // parameters are separated by '%'\n"
		"    meth.call( \"1000%666%_\", \"%\" );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    # call a function expecting a string and a float\n"
		"    # value parameters separated by spaces\n"
		"    meth.call(\"stringParam 3,14\")\n"
		"    # call of a function expecting 2 integers an a string\n"
		"    # where an empty string shall be passed\n"
		"    # parameters are separated by '%'\n"
		"    meth.call(\"1000%666%_\", \"%\")\n"
		"}\n"
		":rtype: int\n"
		":return: An integer value. For a typical function that is part of the driver SDK this integer value will be\n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type params: string\n"
		":param params: [in] The parameters to be passed to the function as a single string\n"
		":type delimiters: string\n"
		":param delimiters: [in] A string containing valid delimiter characters for the parameter string\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Calls an underlying driver function.\n"
		"This function can be used to call any driver function which is registered\n"
		"for the device it is called for. To call a function successfully the parameters\n"
		"passed to the function must match the parameters expected by the function.\n"
		"\n"
		"All parameters are passed as a single string, which is parsed with respect to the\n"
		"given delimiter characters internally.\n"
		"\n"
		"To find out what kind of parameters are expected by the function use\n"
		"the function **mvIMPACT::acquire::Method::paramList()**.\n"
		"\n"
		"floating point values can be passed either with a '.' or a ',' acting as the\n"
		"decimal point.\n"
		"\n"
		"'empty' strings can be passed as a single underline('_').\n"
		"\n"
		"\n"
		"The characters '.', ',' and '_' can't be used as delimiters.\n"
		"\n"
		"If: (DOXYGEN_CPP_DOCUMENTATION { || DOXYGEN_JAVA_DOCUMENTATION)\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    // call a function expecting a string and a float\n"
		"    // value parameters separated by spaces\n"
		"    meth.call( \"stringParam 3,14\" );\n"
		"    // call of a function expecting 2 integers an a string\n"
		"    // where an empty string shall be passed\n"
		"    // parameters are separated by '%'\n"
		"    meth.call( \"1000%666%_\", \"%\" );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    # call a function expecting a string and a float\n"
		"    # value parameters separated by spaces\n"
		"    meth.call(\"stringParam 3,14\")\n"
		"    # call of a function expecting 2 integers an a string\n"
		"    # where an empty string shall be passed\n"
		"    # parameters are separated by '%'\n"
		"    meth.call(\"1000%666%_\", \"%\")\n"
		"}\n"
		":rtype: int\n"
		":return: An integer value. For a typical function that is part of the driver SDK this integer value will be\n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type params: string\n"
		":param params: [in] The parameters to be passed to the function as a single string\n"
		":param delimiters: [in] A string containing valid delimiter characters for the parameter string\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Calls an underlying driver function expecting no parameters.\n"
		"This function can be used to call any driver function which is registered\n"
		"for the device it is called for that does **NOT** expect any parameters\n"
		"\n"
		"To find out what kind of parameters are expected by the function use\n"
		"the function **mvIMPACT::acquire::Method::paramList()**.\n"
		"\n"
		":rtype: int\n"
		":return: An integer value. For a typical function that is part of the driver SDK this integer value will be\n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "Method_paramList", _wrap_Method_paramList, METH_O, "\n"
		"Returns the parameter list of the methods as a string.\n"
		"This function returns a string containing one character for each parameter this **mvIMPACT::acquire::Method**\n"
		"object expects and one for the return type of the function call.\n"
		"\n"
		"The first character is the return type of the function all others are parameters. void functions\n"
		"don't specify parameters.\n"
		"\n"
		"The characters have the following meaning:\n"
		"- i specifies a 32-bit integer value\n"
		"- I specifies a 64-bit integer value\n"
		"- s specifies a pointer to a C-string\n"
		"- f specifies a double precision float value\n"
		"- p specifies a pointer value\n"
		"- v specifies a void return value\n"
		"\n"
		"**EXAMPLES**:\n"
		"\n"
		"- 'v': This is a function returning nothing (void). It expects no parameters.\n"
		"- 'viis': This is a function returning nothing (void). It expects 2 integer values\n"
		"and one pointer to a C-string.\n"
		"- 'if': This function returns an integer value and expects a float value.\n"
		":rtype: string\n"
		":return: The parameter list of the method as a string.\n"
		""},
	 { "delete_Method", _wrap_delete_Method, METH_O, NULL},
	 { "Method_swigregister", Method_swigregister, METH_O, NULL},
	 { "Method_swiginit", Method_swiginit, METH_VARARGS, NULL},
	 { "new_Property", _wrap_new_Property, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::Property** object.\n"
		" Properties constructed this way can't be used for anything unless they\n"
		" are bound to a internal driver property with a **mvIMPACT::acquire::ComponentLocator** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::Property** object.\n"
		" Properties successfully constructed this way can be worked with directly.\n"
		" If *hObj* does not reference an internal driver property a **mvIMPACT::acquire::ENotAProperty**\n"
		" exception will be thrown.\n"
		"\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to a property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::Property** from an existing one.\n"
		":type src: :py:class:`Property`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::Property** object, this object shall be created from\n"
		""},
	 { "Property_getAllowsValueCombinations", _wrap_Property_getAllowsValueCombinations, METH_O, "\n"
		" Checks if this enumerated property allows the combination of enum values.\n"
		" If this function returns true, the enum constants can be 'ored' together. This works\n"
		" for the enum constants as well as for the string representations returned in the\n"
		" properties translation dictionary.\n"
		"\n"
		" if a property e.g. defines a dictionary (('1', \"one\"), ('2', \"two\")) the following\n"
		" write operations will be valid:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     prop = getPropFromSomewhere()\n"
		"     prop.write( 1 | 2 )\n"
		"     prop.write( \"one | two\" )\n"
		"\n"
		" If this function returns true code like this will be valid:\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     enum TEnum\n"
		"     {\n"
		"       eA,\n"
		"       eB\n"
		"     };\n"
		"\n"
		"     typedef EnumPropertyITEnum PropertyIEnum;\n"
		"     PropertyIEnum p = getPropFromSomewhere();\n"
		"     p.write( TEnum(eA | eB) );\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     ImageProcessing ip = new ImageProcessing( pDev );\n"
		"     ip.getMirrorMode().write( TMirrorMode.mmTopDown | TMirrorMode.mmLeftRight );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     prop = getPropFromSomewhere()\n"
		"     prop.write(1 | 2)\n"
		"     prop.write(\"one | two\")\n"
		" }\n"
		" :rtype: boolean\n"
		" :return: \n"
		"     - true if this property allows the combination of enum values.\n"
		"     - false otherwise.\n"
		""},
	 { "Property_dictSize", _wrap_Property_dictSize, METH_O, "\n"
		"Returns the size of the properties translation dictionary.\n"
		"If the property does define a translation dictionary this function returns\n"
		"the number of elements contained in this dictionary.\n"
		":rtype: int\n"
		":return: \n"
		"    - The size of the properties translation dictionary.\n"
		"    - 0 If this property does not define a translation dictionary.\n"
		""},
	 { "Property_getHasDict", _wrap_Property_getHasDict, METH_O, "\n"
		"Returns whether this property defines a translation dictionary or not.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if this property defines a translation table\n"
		"    - false otherwise\n"
		""},
	 { "Property_getHasMaxValue", _wrap_Property_getHasMaxValue, METH_O, "\n"
		"Checks if a maximum value is defined for this property.\n"
		"Since: 1.12.63\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if this property defines a maximum value\n"
		"    - false otherwise\n"
		""},
	 { "Property_getHasMinValue", _wrap_Property_getHasMinValue, METH_O, "\n"
		"Checks if a minimum value is defined for this property.\n"
		"Since: 1.12.63\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if this property defines a minimum value\n"
		"    - false otherwise\n"
		""},
	 { "Property_getHasStepWidth", _wrap_Property_getHasStepWidth, METH_O, "\n"
		"Checks if a step width is defined for this property.\n"
		"Since: 1.12.63\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if this property defines a step width\n"
		"    - false otherwise\n"
		""},
	 { "Property_readS", _wrap_Property_readS, METH_VARARGS, "\n"
		" Reads data from this property as a string.\n"
		" Notes: If the caller does not have the needed rights this function might throw an\n"
		" exception of the type **mvIMPACT::acquire::ImpactAcquireException**.\n"
		"\n"
		" :rtype: string\n"
		" :return: A string containing the data questioned.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the desired value(only necessary for properties containing more than one value)\n"
		":type format: string\n"
		":param format: [in] The format string telling the function how to format the result. If left empty the property uses its standard way of converting its data into a string\n"
		""},
	 { "Property_readSArray", _wrap_Property_readSArray, METH_VARARGS, "\n"
		" Reads data from this property as a string.\n"
		" This function can be used to query a set of values if this property stores more\n"
		" than a single value which might be useful for GUI applications.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     PropertyI p = getPropFromSomewhere();\n"
		"     p.write( 1 );\n"
		"     p.write( 2, 1 );\n"
		"     p.write( 666, 2 );\n"
		"     std::string s = p.readSArray( \"%d\", \"&&:\", 1 );\n"
		"     // now s should contain '2:666'\n"
		"     s = p.readSArray( \"%4d\", \" \", 0, 1 );\n"
		"     // now s should contain '   1,   2'\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     PropertyI p = getPropFromSomewhere();\n"
		"     p.write( 1 );\n"
		"     p.write( 2, 1 );\n"
		"     p.write( 666, 2 );\n"
		"     String s = p.readSArray( \"%d\", \"&&:\", 1 );\n"
		"     // now s should contain '2:666'\n"
		"     s = p.readSArray( \"%4d\", \" \", 0, 1 );\n"
		"     // now s should contain '   1,   2'\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     PropertyI p = getPropFromSomewhere()\n"
		"     p.write(1)\n"
		"     p.write(2, 1)\n"
		"     p.write(666, 2)\n"
		"     s = p.readSArray(\"%d\", \"&&:\", 1)\n"
		"     # now s should contain '2:666'\n"
		"     s = p.readSArray(\"%4d\", \" \", 0, 1)\n"
		"     # now s should contain '   1,   2'\n"
		"}\n"
		"\n"
		" Notes: If the caller does not have the needed rights this function might throw an\n"
		" exception of the type **mvIMPACT::acquire::ImpactAcquireException**.\n"
		"\n"
		" :rtype: string\n"
		" :return: A string containing the data questioned.\n"
		"\n"
		":type format: string\n"
		":param format: [in] The format string telling the function how to format the result. If left empty the property uses its standard way of converting its data into a string\n"
		":type delimiter: string\n"
		":param delimiter: [in] This string is used to separate the individual values from one another. If left empty, a single blank will separate the data.\n"
		":type startIndex: int\n"
		":param startIndex: [in] The index of the first of the desired values\n"
		":type endIndex: int\n"
		":param endIndex: [in] The index of the last of the desired values. If **INT_MAX** is passed, every from *startIndex* to the last value stored by the property will be returned.\n"
		":type mode: int\n"
		":param mode: [in] Specifies the mode this function operates in. Currently only the LSB affects the behaviour of this function. When the LSB is set, the translation dictionary (if defined) will be ignored for this call.\n"
		""},
	 { "Property_removeValue", _wrap_Property_removeValue, METH_VARARGS, "\n"
		" Removes a certain value from the property's data.\n"
		" :rtype: :py:class:`Property`\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to be removed\n"
		""},
	 { "Property_resizeValArray", _wrap_Property_resizeValArray, METH_VARARGS, "\n"
		" Resizes the property's data array.\n"
		" This function resizes the internal data array of this property. The size of\n"
		" this array represents the number of values, which can be stored within the\n"
		" property. This function will only succeed, if the **mvIMPACT::acquire::cfFixedSize**\n"
		" is **NOT** set for this property and the user has **\"write rights\"** for this property.\n"
		" Otherwise an exception will be thrown. Whenever the user successfully writes an\n"
		" array of values to a property and this array contains more elements than the current\n"
		" internal data array can accommodate at the desired offset the internal data array\n"
		" will be increased automatically.\n"
		"\n"
		" Notes: If the caller does not have the needed rights this function might throw an\n"
		" exception of the type **mvIMPACT::acquire::ImpactAcquireException**.\n"
		"\n"
		" In order to be allowed to modify the number of values a property\n"
		" can store, the **mvIMPACT::acquire::cfFixedSize** flag\n"
		" must **NOT** be set.\n"
		" See also: \n"
		" **mvIMPACT::acquire::Component::isWriteable**\n"
		"\n"
		" :rtype: :py:class:`Property`\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type newSize: int\n"
		":param newSize: [in] The new number of values this property shall be allowed to store\n"
		""},
	 { "Property_stringFormatString", _wrap_Property_stringFormatString, METH_O, "\n"
		"Returns the internal format string this property uses to convert data to strings.\n"
		":rtype: string\n"
		":return: A string containing the format string internally used by the property\n"
		"    whenever the user reads a value as a string without specifying a format string and\n"
		"    the property is not a string type one.\n"
		""},
	 { "Property_valCount", _wrap_Property_valCount, METH_O, "\n"
		"Returns the current number of values managed by this property.\n"
		"For the majority of properties this function will return '1', but as properties\n"
		"might manage more than a single value, this value might be interesting from time\n"
		"to time.\n"
		":rtype: int\n"
		":return: the current number of values managed by this property.\n"
		""},
	 { "Property_maxValCount", _wrap_Property_maxValCount, METH_O, "\n"
		"Returns maximum number of values that can be managed by this property.\n"
		"For the majority of properties this function will return '1', but as properties\n"
		"might manage more than a single value, this value might be interesting from time\n"
		"to time.\n"
		":rtype: int\n"
		":return: the maximum number of values that can be managed by this property.\n"
		""},
	 { "Property_writeS", _wrap_Property_writeS, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Assigns a new value to this property.\n"
		" The user caller have **\"write rights\"** for this property in order to be able to\n"
		" modify its value. Also if *index* is greater than the current internal data array\n"
		" size of this property the user must be allowed to change to size of the properties\n"
		" internal data array (the **mvIMPACT::acquire::cfFixedSize** flag must **NOT** be set).\n"
		"\n"
		" Notes: If the caller does not have the needed rights this function might throw an\n"
		" exception of the type **mvIMPACT::acquire::ImpactAcquireException**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Component::isWriteable**,\n"
		"\n"
		" **mvIMPACT::acquire::Component::flags**,\n"
		"\n"
		" **mvIMPACT::acquire::Property::writeS**\n"
		"\n"
		" :rtype: :py:class:`Property`\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type value: string\n"
		":param value: [in] The new value for this property at the given *index*.\n"
		":type index: int\n"
		":param index: [in] The index of the value to modify\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Assigns new values to this property.\n"
		" The user must have **\"write rights\"** for this property in order to be able to\n"
		" modify its values. Also if *index* is greater than the current internal data array\n"
		" size of this property the user must be allowed to change to size of the properties\n"
		" internal data array (the **mvIMPACT::acquire::cfFixedSize** flag must **NOT** be set). This\n"
		" function behaves exactly like **mvIMPACT::acquire::Property::writeS**\n"
		" except that is can be used to assign more than one value at the same time. The parameter\n"
		" *index* here serves as an offset. If for example a property holds 3 values 'one', 'two'\n"
		" and 'three' before this call and the function is then called with an array containing the\n"
		" string 'orange' and 'blue' and *index* = 2 then after a successful call to this function\n"
		" the property will hold the data 'one', 'two', 'orange' and 'blue'.\n"
		"\n"
		" Notes: If the caller does not have the needed rights this function might throw an\n"
		" exception of the type **mvIMPACT::acquire::ImpactAcquireException**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Component::isWriteable**,\n"
		"**mvIMPACT::acquire::Component::flags**,\n"
		"\n"
		" **mvIMPACT::acquire::Property::writeS**\n"
		"\n"
		" :rtype: :py:class:`Property`\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [in] A constant reference to an array containing the strings to be assigned to the property\n"
		":type index: int\n"
		":param index: [in] The offset from where to start to assign the values\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Assigns new values to this property.\n"
		" The user must have **\"write rights\"** for this property in order to be able to\n"
		" modify its values. Also if *index* is greater than the current internal data array\n"
		" size of this property the user must be allowed to change to size of the properties\n"
		" internal data array (the **mvIMPACT::acquire::cfFixedSize** flag must **NOT** be set). This\n"
		" function behaves exactly like **mvIMPACT::acquire::Property::writeS**\n"
		" except that is can be used to assign more than one value at the same time. The parameter\n"
		" *index* here serves as an offset. If for example a property holds 3 values 'one', 'two'\n"
		" and 'three' before this call and the function is then called with an array containing the\n"
		" string 'orange' and 'blue' and *index* = 2 then after a successful call to this function\n"
		" the property will hold the data 'one', 'two', 'orange' and 'blue'.\n"
		"\n"
		" Notes: If the caller does not have the needed rights this function might throw an\n"
		" exception of the type **mvIMPACT::acquire::ImpactAcquireException**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Component::isWriteable**,\n"
		"**mvIMPACT::acquire::Component::flags**,\n"
		"\n"
		" **mvIMPACT::acquire::Property::writeS**\n"
		"\n"
		" :rtype: :py:class:`Property`\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [in] A constant reference to an array containing the strings to be assigned to the property\n"
		":param index: [in] The offset from where to start to assign the values\n"
		""},
	 { "delete_Property", _wrap_delete_Property, METH_O, NULL},
	 { "Property_swigregister", Property_swigregister, METH_O, NULL},
	 { "Property_swiginit", Property_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyPtr", _wrap_new_PropertyPtr, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::PropertyPtr** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::PropertyPtr** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to a pointer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::PropertyPtr** from an existing one.\n"
		":type src: :py:class:`PropertyPtr`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::PropertyPtr** object, this object shall be created from\n"
		""},
	 { "PropertyPtr_read", _wrap_PropertyPtr_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: void\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< void *,std::allocator< void * > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< void *,std::allocator< void * > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< void *,std::allocator< void * > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyPtr_write", _wrap_PropertyPtr_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		" :rtype: :py:class:`PropertyPtr`\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: void\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		" :rtype: :py:class:`PropertyPtr`\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< void *,std::allocator< void * > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		" :rtype: :py:class:`PropertyPtr`\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< void *,std::allocator< void * > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyPtr", _wrap_delete_PropertyPtr, METH_O, NULL},
	 { "PropertyPtr_swigregister", PropertyPtr_swigregister, METH_O, NULL},
	 { "PropertyPtr_swiginit", PropertyPtr_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyS", _wrap_new_PropertyS, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::PropertyS** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::PropertyS** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to the string property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::PropertyS** from an existing one.\n"
		":type src: :py:class:`PropertyS`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyS** object, this object shall be created from\n"
		""},
	 { "PropertyS_binaryDataBufferSize", _wrap_PropertyS_binaryDataBufferSize, METH_VARARGS, "\n"
		" Returns the size(in bytes) needed for the binary representation of the string buffer.\n"
		" When binary data has been stored in a string property it has been stored in [Base64](https://en.wikipedia.org/wiki/Base64) format\n"
		" internally. If the user wants to know the length of the binary data in decoded format,\n"
		" this function can be called.\n"
		"\n"
		" See also: **mvIMPACT::acquire::PropertyS::readBinary**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::writeBinary**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**\n"
		"\n"
		" :rtype: int\n"
		" :return: The size(in bytes) needed for the binary representation of the string buffer.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value for which to query the buffer size(if this property holds more than one value).\n"
		""},
	 { "PropertyS_binaryDataBufferMaxSize", _wrap_PropertyS_binaryDataBufferMaxSize, METH_O, "\n"
		"Reads the max size(in bytes) of binary data this property can store.\n"
		"When binary data shall be stored in a string property, the user will need to allocate memory\n"
		"when this data shall be written to the property. To find out how much binary data can be stored\n"
		"by a property before calling the function **mvIMPACT::acquire::PropertyS::writeBinary** this function can be used.\n"
		"\n"
		"See also: **mvIMPACT::acquire::PropertyS::readBinary**,\n"
		"\n"
		"    **mvIMPACT::acquire::PropertyS::writeBinary**,\n"
		"\n"
		"    **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**\n"
		"\n"
		":rtype: int\n"
		":return: The size(in bytes) needed for the binary representation of the string buffer.\n"
		""},
	 { "PropertyS_read", _wrap_PropertyS_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: string\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyS_write", _wrap_PropertyS_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: :py:class:`PropertyS`\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: string\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: :py:class:`PropertyS`\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: :py:class:`PropertyS`\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "PropertyS_readBinary", _wrap_PropertyS_readBinary, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value stored in the property as binary data.\n"
		" Binary data can only be stored in string properties. When writing binary data to a string\n"
		" property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data\n"
		" into a read and printable string representation. As a result of this 3 bytes of arbitrary binary\n"
		" data will occupy 4 bytes of memory.\n"
		"\n"
		" Reading binary data with this function obviously only makes sense if the property has been assigned\n"
		" the value by a previous call to **mvIMPACT::acquire::PropertyS::writeBinary** (here you find a small code example as well).\n"
		" However using this method any kind of data can be stored by a string property.\n"
		" This can e.g. be interesting when certain data shall be stored in the\n"
		" user accessible part of the devices non-volatile memory.\n"
		"\n"
		" See also: **mvIMPACT::acquire::PropertyS::writeBinary**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**\n"
		" :rtype: string\n"
		" :return: The binary data representation of the specified property value as a new std::string object.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to get(if this property holds more than one value).\n"
		":type boLegacyMode: boolean\n"
		":param boLegacyMode: [in] If set to *true* this allows applications compiled with mvIMPACT Acquire 2.32.0 or greater using this function to run on systems with mvIMPACT Acquire smaller than 2.32.0. The legacy version of this function runs slower!\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a value stored in the property as binary data.\n"
		" Binary data can only be stored in string properties. When writing binary data to a string\n"
		" property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data\n"
		" into a read and printable string representation. As a result of this 3 bytes of arbitrary binary\n"
		" data will occupy 4 bytes of memory.\n"
		"\n"
		" Reading binary data with this function obviously only makes sense if the property has been assigned\n"
		" the value by a previous call to **mvIMPACT::acquire::PropertyS::writeBinary** (here you find a small code example as well).\n"
		" However using this method any kind of data can be stored by a string property.\n"
		" This can e.g. be interesting when certain data shall be stored in the\n"
		" user accessible part of the devices non-volatile memory.\n"
		"\n"
		" See also: **mvIMPACT::acquire::PropertyS::writeBinary**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**\n"
		"\n"
		":type pBuf: string\n"
		":param pBuf: [in] A pointer to a piece of memory that shall receive bhe binary data stored by the this property.\n"
		":type bufSize: int\n"
		":param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.\n"
		":type index: int\n"
		":param index: [in] The index of the value to get(if this property holds more than one value).\n"
		":type boLegacyMode: boolean\n"
		":param boLegacyMode: [in] If set to *true* this allows applications compiled with mvIMPACT Acquire 2.32.0 or greater using this function to run on systems with mvIMPACT Acquire smaller than 2.32.0. The legacy version of this function runs slower!\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a value stored in the property as binary data.\n"
		" Binary data can only be stored in string properties. When writing binary data to a string\n"
		" property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data\n"
		" into a read and printable string representation. As a result of this 3 bytes of arbitrary binary\n"
		" data will occupy 4 bytes of memory.\n"
		"\n"
		" Reading binary data with this function obviously only makes sense if the property has been assigned\n"
		" the value by a previous call to **mvIMPACT::acquire::PropertyS::writeBinary** (here you find a small code example as well).\n"
		" However using this method any kind of data can be stored by a string property.\n"
		" This can e.g. be interesting when certain data shall be stored in the\n"
		" user accessible part of the devices non-volatile memory.\n"
		"\n"
		" See also: **mvIMPACT::acquire::PropertyS::writeBinary**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**\n"
		"\n"
		":type pBuf: string\n"
		":param pBuf: [in] A pointer to a piece of memory that shall receive bhe binary data stored by the this property.\n"
		":type bufSize: int\n"
		":param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.\n"
		":type index: int\n"
		":param index: [in] The index of the value to get(if this property holds more than one value).\n"
		":param boLegacyMode: [in] If set to *true* this allows applications compiled with mvIMPACT Acquire 2.32.0 or greater using this function to run on systems with mvIMPACT Acquire smaller than 2.32.0. The legacy version of this function runs slower!\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a value stored in the property as binary data.\n"
		" Binary data can only be stored in string properties. When writing binary data to a string\n"
		" property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data\n"
		" into a read and printable string representation. As a result of this 3 bytes of arbitrary binary\n"
		" data will occupy 4 bytes of memory.\n"
		"\n"
		" Reading binary data with this function obviously only makes sense if the property has been assigned\n"
		" the value by a previous call to **mvIMPACT::acquire::PropertyS::writeBinary** (here you find a small code example as well).\n"
		" However using this method any kind of data can be stored by a string property.\n"
		" This can e.g. be interesting when certain data shall be stored in the\n"
		" user accessible part of the devices non-volatile memory.\n"
		"\n"
		" See also: **mvIMPACT::acquire::PropertyS::writeBinary**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**\n"
		"\n"
		":type pBuf: string\n"
		":param pBuf: [in] A pointer to a piece of memory that shall receive bhe binary data stored by the this property.\n"
		":type bufSize: int\n"
		":param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.\n"
		":param index: [in] The index of the value to get(if this property holds more than one value).\n"
		":param boLegacyMode: [in] If set to *true* this allows applications compiled with mvIMPACT Acquire 2.32.0 or greater using this function to run on systems with mvIMPACT Acquire smaller than 2.32.0. The legacy version of this function runs slower!\n"
		""},
	 { "PropertyS_writeBinary", _wrap_PropertyS_writeBinary, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes a block of binary data to one entry of the property.\n"
		" Binary data can only be stored in string properties. When writing binary data to a string\n"
		" property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data\n"
		" into a read and printable string representation. As a result of this 3 bytes of arbitrary binary\n"
		" data will occupy 4 bytes of memory.\n"
		"\n"
		" By writing binary data with this function arbitrary data can be stored by a string property.\n"
		" This can e.g. be interesting when certain data shall be stored in the\n"
		" user accessible part of the devices non-volatile memory.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     char binData [6] = { 'A', 'B', 0x00, -128, 'E', 'F' };\n"
		"     const string value( binData, sizeof( binData ) / sizeof( binData[0] ) );\n"
		"     PropertyS prop( getHandleFromSomewhere() );\n"
		"     prop.writeBinary( value );\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     final int BUF_SIZE = 6;\n"
		"     byte[] data_bytes = new byte[BUF_SIZE];\n"
		"     data_bytes[0] = 0x00;\n"
		"     data_bytes[1] = -1;\n"
		"     data_bytes[2] = -128;\n"
		"     data_bytes[3] = 0x33;\n"
		"     ByteBuffer data = ByteBuffer.allocateDirect( BUF_SIZE );\n"
		"     data.put( data_bytes );\n"
		"     binaryProp = acquire.PropertyS( getHandleFromSomewhere() )\n"
		"     binaryProp.writeBinary( data );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     binData = ''\n"
		"     binaryProp = acquire.PropertyS(getHandleFromSomewhere())\n"
		"     binaryProp.writeBinary(binData)\n"
		"}\n"
		"\n"
		" To find out if a property contains binary data check if **mvIMPACT::acquire::cfContainsBinaryData** is set e.g. by calling\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     PropertyS prop( getHandleFromSomewhere() );\n"
		"     if( prop.flags()  cfContainsBinaryData )\n"
		"     {\n"
		"       // Yes!! Binary data\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     PropertyS prop = new PropertyS( getHandleFromSomewhere() );\n"
		"     if( ( prop.flags()  TComponentFlag.cfContainsBinaryData ) == TComponentFlag.cfContainsBinaryData )\n"
		"     {\n"
		"       // Yes!! Binary data\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     binaryProp = acquire.PropertyS(getHandleFromSomewhere())\n"
		"     if pseudoBinaryProp.flags()  acquire.cfContainsBinaryData:\n"
		"         # Yes!! Binary data!\n"
		" }\n"
		"\n"
		"Performance considerations:\n"
		"\n"
		"mvIMPACT Acquire 2.15.0 and newer:\n"
		"\n"
		"- Base64 encoding/decoding only is performed when read string data previously written as binary data and vice versa.\n"
		"- encoding/decoding only is performed if the 2 internal caches are out of sync. so only on the first read access using the other format.\n"
		"- this version is more efficient compared to previous implementations.\n"
		"\n"
		" class=\"interactive_dotgraph\"\n"
		"\n"
		"\n"
		"\n"
		"mvIMPACT Acquire versions smaller than 2.15.0\n"
		"\n"
		"- Base64 encoding/decoding always is performed when reading/writing data in binary format.\n"
		"\n"
		" class=\"interactive_dotgraph\"\n"
		"\n"
		"\n"
		"\n"
		"Notes: \n"
		"When a property stores binary data that came from a GenICam chunk buffer additional copy operations from the GenApi runtime will take place. This can be\n"
		"considered as an additional copy operation into the application binary buffer. So binary chunk data should be avoided if possible!\n"
		"\n"
		" See also: **mvIMPACT::acquire::PropertyS::readBinary**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" :rtype: :py:class:`PropertyS`\n"
		" :return: A const 'self' reference.\n"
		" }\n"
		"\n"
		":type value: string\n"
		":param value: [in] A const reference to the string holding the binary data that shall be stored by the this property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a block of binary data to one entry of the property.\n"
		" Binary data can only be stored in string properties. When writing binary data to a string\n"
		" property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data\n"
		" into a read and printable string representation. As a result of this 3 bytes of arbitrary binary\n"
		" data will occupy 4 bytes of memory.\n"
		"\n"
		" By writing binary data with this function arbitrary data can be stored by a string property.\n"
		" This can e.g. be interesting when certain data shall be stored in the\n"
		" user accessible part of the devices non-volatile memory.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     char binData [6] = { 'A', 'B', 0x00, -128, 'E', 'F' };\n"
		"     const string value(binData, sizeof(binData) / sizeof(binData[0] ));\n"
		"     PropertyS prop(getHandleFromSomewhere());\n"
		"     prop.writeBinary( value );\n"
		" }\n"
		"\n"
		" To find out if a property contains binary data check if **mvIMPACT::acquire::cfContainsBinaryData** is set e.g. by calling\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     PropertyS prop(getHandleFromSomewhere());\n"
		"     if( prop.flags()  cfContainsBinaryData )\n"
		"     {\n"
		"       // Yes!! Binary data\n"
		"     }\n"
		" }\n"
		"\n"
		"Performance considerations:\n"
		"\n"
		"mvIMPACT Acquire 2.15.0 and newer:\n"
		"\n"
		"- Base64 encoding/decoding only is performed when read string data previously written as binary data and vice versa.\n"
		"- encoding/decoding only is performed if the 2 internal caches are out of sync. so only on the first read access using the other format.\n"
		"- this version is more efficient compared to previous implementations.\n"
		"\n"
		" class=\"interactive_dotgraph\"\n"
		"\n"
		"\n"
		"\n"
		"mvIMPACT Acquire versions smaller than 2.15.0\n"
		"\n"
		"- Base64 encoding/decoding always is performed when reading/writing data in binary format.\n"
		"\n"
		" class=\"interactive_dotgraph\"\n"
		"\n"
		"\n"
		"\n"
		"Notes: \n"
		"When a property stores binary data that came from a GenICam chunk buffer additional copy operations from the GenApi runtime will take place. This can be\n"
		"considered as an additional copy operation into the application binary buffer. So binary chunk data should be avoided if possible!\n"
		"\n"
		" See also: **mvIMPACT::acquire::PropertyS::readBinary**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**\n"
		"\n"
		":type pBuf: string\n"
		":param pBuf: [in] A const pointer to a piece of memory holding the binary data that shall be stored by the this property.\n"
		":type bufSize: int\n"
		":param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a block of binary data to one entry of the property.\n"
		" Binary data can only be stored in string properties. When writing binary data to a string\n"
		" property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data\n"
		" into a read and printable string representation. As a result of this 3 bytes of arbitrary binary\n"
		" data will occupy 4 bytes of memory.\n"
		"\n"
		" By writing binary data with this function arbitrary data can be stored by a string property.\n"
		" This can e.g. be interesting when certain data shall be stored in the\n"
		" user accessible part of the devices non-volatile memory.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     char binData [6] = { 'A', 'B', 0x00, -128, 'E', 'F' };\n"
		"     const string value(binData, sizeof(binData) / sizeof(binData[0] ));\n"
		"     PropertyS prop(getHandleFromSomewhere());\n"
		"     prop.writeBinary( value );\n"
		" }\n"
		"\n"
		" To find out if a property contains binary data check if **mvIMPACT::acquire::cfContainsBinaryData** is set e.g. by calling\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     PropertyS prop(getHandleFromSomewhere());\n"
		"     if( prop.flags()  cfContainsBinaryData )\n"
		"     {\n"
		"       // Yes!! Binary data\n"
		"     }\n"
		" }\n"
		"\n"
		"Performance considerations:\n"
		"\n"
		"mvIMPACT Acquire 2.15.0 and newer:\n"
		"\n"
		"- Base64 encoding/decoding only is performed when read string data previously written as binary data and vice versa.\n"
		"- encoding/decoding only is performed if the 2 internal caches are out of sync. so only on the first read access using the other format.\n"
		"- this version is more efficient compared to previous implementations.\n"
		"\n"
		" class=\"interactive_dotgraph\"\n"
		"\n"
		"\n"
		"\n"
		"mvIMPACT Acquire versions smaller than 2.15.0\n"
		"\n"
		"- Base64 encoding/decoding always is performed when reading/writing data in binary format.\n"
		"\n"
		" class=\"interactive_dotgraph\"\n"
		"\n"
		"\n"
		"\n"
		"Notes: \n"
		"When a property stores binary data that came from a GenICam chunk buffer additional copy operations from the GenApi runtime will take place. This can be\n"
		"considered as an additional copy operation into the application binary buffer. So binary chunk data should be avoided if possible!\n"
		"\n"
		" See also: **mvIMPACT::acquire::PropertyS::readBinary**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,\n"
		"\n"
		"     **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**\n"
		"\n"
		":type pBuf: string\n"
		":param pBuf: [in] A const pointer to a piece of memory holding the binary data that shall be stored by the this property.\n"
		":type bufSize: int\n"
		":param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.\n"
		":param index: [in] The index defining at which position to write the value.\n"
		""},
	 { "delete_PropertyS", _wrap_delete_PropertyS, METH_O, NULL},
	 { "PropertyS_swigregister", PropertyS_swigregister, METH_O, NULL},
	 { "PropertyS_swiginit", PropertyS_swiginit, METH_VARARGS, NULL},
	 { "UserDataEntry_getUDEIsValid", _wrap_UserDataEntry_getUDEIsValid, METH_O, "\n"
		"Call this function to check if this object references an existing entry.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if this object references an existing entry\n"
		"    - false otherwise\n"
		""},
	 { "UserDataEntry_name_get", _wrap_UserDataEntry_name_get, METH_O, "\n"
		"The name of the entry.\n"
		"The maximum length for the name currently is 255 characters.\n"
		""},
	 { "UserDataEntry_data_get", _wrap_UserDataEntry_data_get, METH_O, "\n"
		"The data stored in this entry.\n"
		"The theoretical limit for the amount of data per entry is 2^16 (64KB) bytes,\n"
		"however the real limit might be below this value because the device does not offer\n"
		"that much memory.\n"
		"\n"
		"This property can either store string or binary data. See **mvIMPACT::acquire::PropertyS** to find\n"
		"out how to work with binary data.\n"
		""},
	 { "UserDataEntry_access_get", _wrap_UserDataEntry_access_get, METH_O, "\n"
		"The access rights for this entry.\n"
		"After this entry has been written to the devices non-volatile memory, this property\n"
		"will become **read-only**.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TUserDataAccessRight**.\n"
		""},
	 { "UserDataEntry_password_get", _wrap_UserDataEntry_password_get, METH_O, "\n"
		"The password needed to modify this entry.\n"
		"The maximum length for the password is 255 characters currently. When the\n"
		"**mvIMPACT::acquire::udarPassword** is not specified\n"
		"by the *access* property, this property will be ignored. Otherwise this\n"
		"property must have been assigned the correct password (case sensitive) before\n"
		"the *name* and *data* properties can be modified.\n"
		""},
	 { "delete_UserDataEntry", _wrap_delete_UserDataEntry, METH_O, NULL},
	 { "UserDataEntry_swigregister", UserDataEntry_swigregister, METH_O, NULL},
	 { "UserData_createEntry", _wrap_UserData_createEntry, METH_O, "\n"
		"Creates and returns a new entry to store user specific data.\n"
		"Notes: \n"
		"The data handled by this object will not be stored permanently in the devices non-volatile\n"
		"memory until **mvIMPACT::acquire::UserData::writeToHardware** has been called successfully.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::UserData::deleteEntry**,\n"
		"\n"
		"   mvIMPACT::acquire::UserData::writeToHardware\n"
		":rtype: :py:class:`UserDataEntry`\n"
		":return: A new **mvIMPACT::acquire::UserDataEntry** instance that can be used to store user specific data\n"
		"    in the devices non-volatile memory.\n"
		""},
	 { "UserData_deleteEntry", _wrap_UserData_deleteEntry, METH_VARARGS, "\n"
		" Deletes an entry of user specific data.\n"
		" If the entry has been stored to the non-volatile memory already and has been assigned\n"
		" the **mvIMPACT::acquire::udarPassword** flag, this call will fail, when\n"
		" **mvIMPACT::acquire::UserDataEntry::password** does not contain the correct password.\n"
		" Notes: \n"
		" The data handled by this object will not be removed permanently from the devices non-volatile\n"
		" memory until **mvIMPACT::acquire::UserData::writeToHardware(** void ) const has been called successfully.\n"
		" See also: \n"
		" **mvIMPACT::acquire::UserData::createEntry**,\n"
		"\n"
		"     mvIMPACT::acquire::UserData::writeToHardware\n"
		"\n"
		":type userDataEntry: :py:class:`UserDataEntry`\n"
		":param userDataEntry: [in] A reference to the entry to delete\n"
		""},
	 { "UserData_getFreeMemory", _wrap_UserData_getFreeMemory, METH_O, "\n"
		"Returns the number of bytes of user accessible, non-volatile memory that is still available.\n"
		"\n"
		"Since: 1.12.64\n"
		""},
	 { "UserData_getUserDataEntry", _wrap_UserData_getUserDataEntry, METH_VARARGS, "\n"
		" Returns An object to work with an existing entry of user specific data.\n"
		" Notes: \n"
		" If an invalid number has been passed as *nr* an object will be returned as well. Therefore\n"
		" always check if the entry is valid by calling **mvIMPACT::acquire::UserDataEntry::isValid** before\n"
		" working with the object.\n"
		"\n"
		" :rtype: :py:class:`UserDataEntry`\n"
		" :return: An object to work with an existing entry of user specific data.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the entry to return\n"
		""},
	 { "UserData_validUserDataEntryIndexes", _wrap_UserData_validUserDataEntryIndexes, METH_VARARGS, "\n"
		" Fills an array with all currently valid user data entry indexes.\n"
		" This function can be used to obtain a list of valid parameters for calls to the function **mvIMPACT::acquire::UserData::getUserDataEntry**.\n"
		" Every value in the returned array will (when passed to the function **mvIMPACT::acquire::UserData::getUserDataEntry)** result in a\n"
		" valid **mvIMPACT::acquire::UserDataEntry** object.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [out] A reference to the array receiving the list of valid indexes\n"
		""},
	 { "UserData_getIsAvailable", _wrap_UserData_getIsAvailable, METH_O, "\n"
		"This function should be called to check if this device offers non-volatile memory that can be accessed by the user.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the device offers non-volatile memory that can be accessed by the user\n"
		"    - false otherwise\n"
		""},
	 { "UserData_writeToHardware", _wrap_UserData_writeToHardware, METH_O, "\n"
		"Writes the current set of user data into the devices non-volatile memory.\n"
		"This function might take a while. Depending on the device architecture and the amount of\n"
		"memory up to some hundred ms. Therefore make sure this function is not called more often\n"
		"than necessary to let your application perform efficiently.\n"
		"See also: \n"
		"**mvIMPACT::acquire::UserData::createEntry**,\n"
		"\n"
		"**mvIMPACT::acquire::UserData::deleteEntry**\n"
		""},
	 { "UserData_reconnectBehaviour_get", _wrap_UserData_reconnectBehaviour_get, METH_O, "\n"
		"An enumerated integer property that can be used to configure how the user data should be treated in case of a device that has been unplugged is plugged back in again.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TUserDataReconnectBehaviour**.\n"
		"\n"
		"If a device does not support hot-plugging, this property will be invisible (**mvIMPACT::acquire::Component::isVisible())**,\n"
		""},
	 { "UserData_memoryAvailable_bytes_get", _wrap_UserData_memoryAvailable_bytes_get, METH_O, " An integer property **(read-only)** containing the number of bytes of user accessible, non-volatile memory this device has available."},
	 { "UserData_memoryConsumed_bytes_get", _wrap_UserData_memoryConsumed_bytes_get, METH_O, "\n"
		"An integer property **(read-only)** containing the number of bytes of user accessible, non-volatile memory currently consumed by user data.\n"
		"This doesn't indicate that all the data has already been stored in the non-volatile memory,\n"
		"but is the number of bytes needed to store the current user data permanently. No check for\n"
		"overflows will be performed. If the user defined data exceeds the size of the available memory,\n"
		"this data will be lost when disconnecting or switching of the supply voltage for this device.\n"
		"\n"
		"To write data permanently into the device call the function **mvIMPACT::acquire::UserData::writeToHardware**\n"
		"But even after calling this function data that exceeds the available memory will be lost when the\n"
		"device looses supply voltage and/or the process terminates.\n"
		""},
	 { "delete_UserData", _wrap_delete_UserData, METH_O, NULL},
	 { "UserData_swigregister", UserData_swigregister, METH_O, NULL},
	 { "new_Device", _wrap_new_Device, METH_O, "\n"
		"Copy constructor.\n"
		"Creates a new object from an existing device object. Keep in mind that this new object\n"
		"will provide access to the very same hardware and therefore you might as well use the original\n"
		"reference returned from the **mvIMPACT::acquire::DeviceManager**. This constructor\n"
		"is only provided for internal reference counting to guarantee correct operation of the\n"
		"objects of this class under all platforms and languages.\n"
		""},
	 { "delete_Device", _wrap_delete_Device, METH_O, "\n"
		"Class destructor.\n"
		"Notes: \n"
		"This destructor must only be called for objects that have been created directly by\n"
		"the user on unmanaged heaps. Under most circumstances this means **NEVER**. E.g. for instances\n"
		"that have been obtained from a **mvIMPACT::acquire::DeviceManager** object do **NOT** call\n"
		"this destructor. The **mvIMPACT::acquire::DeviceManager** will take care of all the\n"
		"resources for you.\n"
		""},
	 { "Device_close", _wrap_Device_close, METH_O, "\n"
		" Closes an opened device.\n"
		" This function closes a device previously opened again.\n"
		"\n"
		"\n"
		" Whenever a device is closed via a call to **mvIMPACT::acquire::Device::close**\n"
		" all other objects constructed with a pointer to that device(e.g. **mvIMPACT::acquire::CameraSettingsBase**\n"
		" before will become invalid and need to be reconstructed afterwards, so don't close a device needlessly.\n"
		"\n"
		" See also: \n"
		" **Device::open**,\n"
		"**Device::isOpen**\n"
		""},
	 { "Device_hasCapability", _wrap_Device_hasCapability, METH_VARARGS, "\n"
		" Checks whether this device has a certain capability.\n"
		" Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceCapability**.\n"
		"\n"
		" :rtype: boolean\n"
		" :return: \n"
		"     - true if the device has the capability in question\n"
		"     - false otherwise.\n"
		"\n"
		":type capability: int\n"
		":param capability: [in] The capability whose presence shall be checked.\n"
		""},
	 { "Device_hasValidLicense", _wrap_Device_hasValidLicense, METH_O, "\n"
		"Checks whether this device has a valid usage license.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Notes: As the name indicates, this property returns if this device has a valid license. Not all third-party vendors\n"
		"are allowed to run with this SDK without limitations, so this function offers a way to check in advance if this is one of them.\n"
		"\n"
		"Since: 2.46.0\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the device has a valid license\n"
		"    - false otherwise.\n"
		""},
	 { "Device_hDev", _wrap_Device_hDev, METH_O, "\n"
		"A unique identifier for this device.\n"
		"Notes: \n"
		"This handle is **NOT** to be confused with the id stored in the devices EEPROM\n"
		"The latter one represents a number stored somewhere in the physical device's EEPROM, while\n"
		"this handle can be assumed as a handle from a software based point of view.\n"
		""},
	 { "Device_hDrv", _wrap_Device_hDrv, METH_O, "\n"
		"A unique identifier for the functionality offered by this device.\n"
		"\n"
		"Notes: \n"
		"This identifier is only valid, if the device has been initialized\n"
		"before by a call to **Device::open**\n"
		""},
	 { "Device_deviceDriverFeatureList", _wrap_Device_deviceDriverFeatureList, METH_O, "\n"
		"Returns a list providing access to driver library specific features.\n"
		"This list does exist only once per device driver library. Changes in this list will affect all\n"
		"devices that are operated using this device driver library.\n"
		"\n"
		"Since: 2.17.0\n"
		""},
	 { "Device_getIsOpen", _wrap_Device_getIsOpen, METH_O, "\n"
		" Returns the current initialisation status in this process.\n"
		" If this function returns *true*, this only states that the current\n"
		" process has not opened the device in question already. A call to **mvIMPACT::acquire::Device::open()**\n"
		" can still fail because of some other process using this device.\n"
		"\n"
		" See also: \n"
		" **Device::open**,\n"
		"**Device::close**\n"
		" :rtype: boolean\n"
		" :return: \n"
		"     - true if the device is initialized(opened) in the current process.\n"
		"     - false otherwise.\n"
		""},
	 { "Device_getIsInUse", _wrap_Device_getIsInUse, METH_O, "\n"
		" Returns the current usage status of this device.\n"
		" If this function returns *true*, this device was not in use at the time of calling this function.\n"
		" A call to **mvIMPACT::acquire::Device::open()** can still fail afterwards if some other process on the system\n"
		" claimed the device in the time between this call and the call to **mvIMPACT::acquire::Device::open()**.\n"
		"\n"
		" See also: \n"
		" **Device::open**,\n"
		"**Device::close**\n"
		"\n"
		" Since: 2.0.11\n"
		" :rtype: boolean\n"
		" :return: \n"
		"     - true if the device is in use by at least one process(this includes the calling process).\n"
		"     - false otherwise.\n"
		""},
	 { "Device_open", _wrap_Device_open, METH_O, "\n"
		"Opens a device.\n"
		"This function will try to open the device represented by this instance of\n"
		"**mvIMPACT::acquire::Device**. If this fails for any reason an exception will be thrown. The exception\n"
		"object will contain additional information about the reason for the error.\n"
		"\n"
		"Calling this function is not really necessary, as each object for accessing\n"
		"other settings of the device or even the function interface need the device to\n"
		"be opened in order to be constructed. Therefore all the constructors for these\n"
		"objects check if the device is open by calling **mvIMPACT::acquire::Device::isOpen** and open\n"
		"the device if necessary.\n"
		"\n"
		"Notes: \n"
		"Keep in mind that the first object trying to open the device might therefore\n"
		"throw an exception as well if opening the device fails for some reason.\n"
		"\n"
		"Whenever a device is opened, the driver executes the following procedure:\n"
		"\n"
		" align=\"center\"Image: src=\"./Device_Setting_Start_Procedure.png\" alt=\"Device_Setting_Start_Procedure.png\"\n"
		"Device setting start procedure\n"
		"\n"
		"Please have a look here (\"el\" href=\"../GUI_page_mvPropView.html\") for more information about automatic loading of\n"
		"settings when a device is opened.\n"
		""},
	 { "Device_setID", _wrap_Device_setID, METH_VARARGS, "\n"
		" Assigns a new ID to this device.\n"
		" To allow any application to distinguish between different devices of the same\n"
		" type the user can assign a unique ID to each device using this function. This ID\n"
		" currently is limited to values between 0 and 250 and is stored in the devices\n"
		" internal memory. This ID is **NOT** volatile. It will remain stored even if\n"
		" the device is unplugged.\n"
		"\n"
		" Notes: \n"
		" **REMARKS**:\n"
		"\n"
		" - The device must be **closed** to assign a new ID.\n"
		" - This ID is not to be confused with the handle returned by the function **mvIMPACT::acquire::Device::hDev**.\n"
		" The latter one represents something which can be assumed as a handle from a software based point\n"
		" of view, while the ID represented by the property **mvIMPACT::acquire::Device::deviceID** is an ID stored in the physical\n"
		" devices EEPROM.\n"
		" - Not every device will offer this feature! When calling this function for a device that does not\n"
		" offer this feature, the function will return **mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Device::open**,\n"
		"**mvIMPACT::acquire::Device::close**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type newID: int\n"
		":param newID: [in] The new *ID* that shall be assigned to the device.\n"
		""},
	 { "Device_updateFirmware", _wrap_Device_updateFirmware, METH_O, "\n"
		" Updates the firmware of the device.\n"
		" Calling this function will cause the driver to download a firmware version compiled\n"
		" into the driver library into the devices non-volatile internal memory.\n"
		"\n"
		" Notes: \n"
		" - This feature currently is only available for **mvBlueFOX** devices. To update the firmware of other devices please refer to the tool ``mvDeviceConfigure(this`` tool also offers a command line interface)\n"
		" - Be sure you know what you are doing **before** calling this function. Under normal circumstances\n"
		" it won't be necessary to update a devices firmware.\n"
		" - The download will take some time (depending on the device up to 30 seconds). During this time\n"
		" the device and the thread calling this function will **NOT** respond.\n"
		" - Do **NOT** interrupt this download.\n"
		" - After a successful download a USB device needs to be unplugged and plugged in again.\n"
		" Otherwise the new firmware version will not be activated.\n"
		" - To download a new firmware version the device must be **closed**.\n"
		" - Not every device will offer this feature! When calling this function for a device that does not\n"
		" offer this feature, the function will return **mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Device::open**,\n"
		"**mvIMPACT::acquire::Device::close**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "Device_getUserData", _wrap_Device_getUserData, METH_O, "\n"
		"Returns a reference to a helper class to handle user specific data stored in the devices non-volatile memory(if available).\n"
		":rtype: :py:class:`UserData`\n"
		":return: A reference to a helper class to handle user specific data stored in the devices\n"
		"    non-volatile memory(if available).\n"
		""},
	 { "Device_validateInterfaceLayout", _wrap_Device_validateInterfaceLayout, METH_VARARGS, "\n"
		"A convenience function mostly used internally. Raises an exception if the current value of **mvIMPACT::acquire::Device::interfaceLayout** does not match the value passed to the function.\n"
		"If a driver does not support the interface layout property this function does nothing!\n"
		""},
	 { "Device_deviceClass_get", _wrap_Device_deviceClass_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** defining the device class this device belongs to.\n"
		"Notes: \n"
		"This property has been added to the device driver in version 1.8.3 thus might not be available when\n"
		"working with old device drivers. Therefore always call the function **mvIMPACT::acquire::Component::isValid**\n"
		"to check if this property is available or not.\n"
		""},
	 { "Device_family_get", _wrap_Device_family_get, METH_O, " A string property **(read-only)** containing the family name of this device."},
	 { "Device_product_get", _wrap_Device_product_get, METH_O, " A string property **(read-only)** containing the product name of this device."},
	 { "Device_capabilities_get", _wrap_Device_capabilities_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** defining special device capabilities.\n"
		"This property stores certain device capabilities that can be read without opening the device.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceCapability**.\n"
		""},
	 { "Device_serial_get", _wrap_Device_serial_get, METH_O, " A string property **(read-only)** containing the serial number of this device."},
	 { "Device_state_get", _wrap_Device_state_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** containing the current state of this device.\n"
		"This property e.g. provides information about the current state of the device. For USB devices this can e.g. indicate whether\n"
		"a device is currently plugged into the system or not.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceState**.\n"
		"\n"
		"**GenICam/GenTL** **device** **specific**:\n"
		"In order to reduce the amount of network traffic to a minimum, this property will only be updated automatically\n"
		"for network devices if the property **mvIMPACT::acquire::Device::registerErrorEvent** is set to\n"
		"**mvIMPACT::acquire::bTrue** (which is the default behaviour). If the IP addresses stay the same the\n"
		"connection is automatically re-established then once the device is detected by the driver again.\n"
		"However if the IP address of the device and/or the network adapter of the system it is used from changes\n"
		"**mvIMPACT::acquire::DeviceManager::updateDeviceList()**\n"
		"must be called regardless of the value of **mvIMPACT::acquire::Device::registerErrorEvent** before a device\n"
		"that was lost can re-establish a connection to the capture driver.\n"
		"Apart from that **ALL** **GenICam/GenTL** will only update this property automatically if the device is\n"
		"currently in use **BY** **THIS** **PROCESS**, so when the device has been opened. This is also to save\n"
		"bandwidth and resources!\n"
		""},
	 { "Device_deviceID_get", _wrap_Device_deviceID_get, METH_O, "\n"
		"An integer property **(read-only)** containing the device ID associated with this device.\n"
		"A device ID can be used to identify a certain device in the system. The ID is an 8 bit unsigned\n"
		"integer value stored in the device's EEPROM. In order to allow the\n"
		"distinct detection of a device via its device ID, the user has to make sure that two devices\n"
		"belonging to the same product family never share the same ID.\n"
		"\n"
		"Notes: \n"
		"**REMARKS**:\n"
		"\n"
		"- To modify the device ID a separate tool will be provided. To modify the device\n"
		"ID without that tool the function **mvIMPACT::acquire::Device::setID** can be called.\n"
		"- This ID is not to be confused with the handle returned by the function **mvIMPACT::acquire::Device::hDev**.\n"
		"The latter one represents something which can be assumed as a handle from a software based point\n"
		"of view, while the ID represented by the property *deviceID* is an ID stored in the physical\n"
		"devices EEPROM.\n"
		""},
	 { "Device_deviceVersion_get", _wrap_Device_deviceVersion_get, METH_O, "\n"
		"A string property **(read-only)** containing the version(e.g. the hard ware revision) of this device.\n"
		"Notes: \n"
		"This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)\n"
		"a driver update will fix this.\n"
		""},
	 { "Device_firmwareVersion_get", _wrap_Device_firmwareVersion_get, METH_O, "\n"
		"An integer property **(read-only)** containing the firmware version of this device.\n"
		"A firmware is considered to be something that is stored in non volatile device memory, thus when a device\n"
		"is disconnected from the power supply and plugged into a different target system the same code will be executed\n"
		"on the device.\n"
		"\n"
		"Some devices however may not support non volatile memory to accommodate a firmware. Typically the device driver then will download\n"
		"a firmware into the devices RAM at startup. Such devices will be considered as not supporting a firmware as in this\n"
		"case only the driver version present on the target system has impact on the devices behaviour.\n"
		"\n"
		"When a device does not support a non volatile firmware, reading this property will always return 0.\n"
		""},
	 { "Device_loadSettings_get", _wrap_Device_loadSettings_get, METH_O, "\n"
		"An enumerated integer property which can be used to define which previously stored setting to load when the device is opened.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceLoadSettings**.\n"
		"\n"
		"Notes: \n"
		"Once the device is in use (has been initialized) this property will become **(read-only)**.\n"
		""},
	 { "Device_autoLoadSettingOrder_get", _wrap_Device_autoLoadSettingOrder_get, METH_O, "\n"
		"A string property **(read-only)** containing the auto load order of feature settings that is executed during initialisation of the device.\n"
		"The first setting detected on the system will be used.\n"
		""},
	 { "Device_interfaceLayout_get", _wrap_Device_interfaceLayout_get, METH_O, "\n"
		"An enumerated integer property which can be used to define which interface layout shall be used when the device is opened.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceInterfaceLayout**.\n"
		"\n"
		"Notes: \n"
		"Once the device is in use (has been initialized) this property will become **(read-only)**.\n"
		"\n"
		"\n"
		"This feature is available for every device. A device not offering this feature requires a driver update. Always check\n"
		"for the availability of this feature by calling **mvIMPACT::acquire::Component::isValid**.\n"
		"\n"
		"Not every device will offer the same options.\n"
		"Check for valid modes by reading the properties translation dictionary with\n"
		"the functions **mvIMPACT::acquire::PropertyIDeviceInterfaceLayout::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyIDeviceInterfaceLayout::getTranslationDictValue**.\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyIDeviceInterfaceLayout::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		""},
	 { "Device_customDataDirectory_get", _wrap_Device_customDataDirectory_get, METH_O, "\n"
		" A string property **(read-only** once the device is open) containing a path to a custom directory for the location of camera description files, etc.\n"
		" When a custom path is assigned to this property this path will be used to locate certain driver specific files\n"
		" and folders. Under this folder the following structure must be created:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     customDataDirectory\n"
		"         |- CameraFiles  // this folder will be searched by frame grabbers for camera description files\n"
		"         |- GenICam      // this folder will be searched by GenICam compliant devices that refer to a local GenICam description file\n"
		"\n"
		" If this property is left empty\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     %PUBLIC%/Documents/MATRIX VISION/mvIMPACT Acquire\n"
		" will be used by default on Windows TM platforms and\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     /etc/matrix-vision/mvimpact-acquire\n"
		" on Linux platforms.\n"
		""},
	 { "Device_defaultRequestCount_get", _wrap_Device_defaultRequestCount_get, METH_O, "\n"
		"An integer property that defines the number of **mvIMPACT::acquire::Request** objects to be created when the device is opened.\n"
		"By writing to this property an application can define the default number of **mvIMPACT::acquire::Request**\n"
		"objects that will be allocated when opening the device.\n"
		"\n"
		"Notes: \n"
		"This property will become read-only while the device is open.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::SystemSettings::requestCount** to change the number of request objects later and to find out why this parameter is important\n"
		""},
	 { "Device_resultQueueCount_get", _wrap_Device_resultQueueCount_get, METH_O, "\n"
		" An integer property that defines the number of result queues to be created when the device is opened.\n"
		" By writing to this property an application can define the number of result queues that will be allocated\n"
		" when opening the device. When requesting buffers the user can define in which result queue a processed request shall\n"
		" end up by writing to the property **mvIMPACT::acquire::ImageRequestControl::resultQueue**. When waiting for a request to become ready by calling **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**\n"
		" the application can specify on which queue to wait.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    Device* pDev = getDevicePointerFromSomewhere();\n"
		"    pDev-resultQueueCount.write( 2 );\n"
		"    ImageRequestControl irc( pDev );\n"
		"    FunctionInterface fi( pDev );\n"
		"    irc.resultQueue.write( 0 );\n"
		"    fi.imageRequestSingle( irc ); // request a buffer that will be stored in queue 0 when ready\n"
		"    irc.resultQueue.write( 1 );\n"
		"    fi.imageRequestSingle( irc ); // request a buffer that will be stored in queue 1 when ready\n"
		"    fi.imageRequestWaitFor( 500, 0 ); // wait on queue 0\n"
		"    fi.imageRequestWaitFor( 500, 1 ); // wait on queue 1\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    Device pDev = getDevicePointerFromSomewhere();\n"
		"    pDev.getResultQueueCount().write( 2 );\n"
		"    ImageRequestControl irc = new ImageRequestControl( pDev );\n"
		"    FunctionInterface fi = new FunctionInterface( pDev );\n"
		"    irc.getResultQueue().write( 0 );\n"
		"    fi.imageRequestSingle( irc ); // request a buffer that will be stored in queue 0 when ready\n"
		"    irc.getResultQueue().write( 1 );\n"
		"    fi.imageRequestSingle( irc ); // request a buffer that will be stored in queue 1 when ready\n"
		"    fi.imageRequestWaitFor( 500, 0 ); // wait on queue 0\n"
		"    fi.imageRequestWaitFor( 500, 1 ); // wait on queue 1\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    pDev = getDeviceFromSomewhere()\n"
		"    pDev.resultQueueCount.write(2)\n"
		"    irc = ImageRequestControl(pDev)\n"
		"    fi = FunctionInterface(pDev)\n"
		"    irc.resultQueue.write(0)\n"
		"    fi.imageRequestSingle(irc) # request a buffer that will be stored in queue 0 when ready\n"
		"    irc.resultQueue.write(1)\n"
		"    fi.imageRequestSingle(irc) # request a buffer that will be stored in queue 1 when ready\n"
		"    fi.imageRequestWaitFor(500, 0) # wait on queue 0\n"
		"    fi.imageRequestWaitFor(500, 1) # wait on queue 1\n"
		"}\n"
		"\n"
		"This can be useful e.g. when working with 2 different settings to sort all buffer capture with setting 0 into one queue\n"
		"and all the others into another queue.\n"
		" Notes: \n"
		" This property will become read-only while the device is open.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::ImageRequestControl::resultQueue**,\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**\n"
		""},
	 { "Device_userControlledImageProcessingEnable_get", _wrap_Device_userControlledImageProcessingEnable_get, METH_O, "\n"
		" An enumerated integer property defining whether user controlled image processing related features shall be created under 'System Settings' or not.\n"
		" Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		" Setting this feature to **mvIMPACT::acquire::bTrue** will result in a separate thread being created when opening the\n"
		" device driver instance. The thread will decouple the host based image processing from the acquisition engine. Apart\n"
		" from that it will also create additional properties in the ``ImageProcessingControl`` list under ``SystemSettings`` that\n"
		" can be used to control the behaviour of this thread. This might be useful e.g. to make sure images can be acquired faster\n"
		" than they can be processed and it is not needed to processed each image.\n"
		"\n"
		" Notes: \n"
		" This property will become read-only while the device is open.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::SystemSettings::imageProcessingMode**\n"
		"\n"
		"**mvIMPACT::acquire::Request::hasProcessingBeenSkipped**\n"
		"\n"
		" Since: 2.14.0\n"
		""},
	 { "Device_allowUnrecommendedFeatures_get", _wrap_Device_allowUnrecommendedFeatures_get, METH_O, "\n"
		"An enumerated integer property which can be used to unlock certain features, that are available but not recommended by the device manufacturer.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"This property will be invisible by default. As the name indicates its use requires special\n"
		"knowledge that can be provided by the device manufacturer on request.\n"
		"\n"
		"Notes: \n"
		"Once the device is in use (has been initialized) this property will become **(read-only)**.\n"
		"\n"
		"\n"
		"Unlocking certain unrecommended features might result in the appearance of new translation\n"
		"dictionary entries for certain properties. Some of these translation strings might contain\n"
		"an exclamation mark ('!') in its name. **NEVER** rely on that! These exclamation marks\n"
		"or even the complete entry might disappear with a new driver release without further notice!\n"
		""},
	 { "Device_acquisitionStartStopBehaviour_get", _wrap_Device_acquisitionStartStopBehaviour_get, METH_O, "\n"
		" An enumerated integer property defining the start/stop behaviour during acquisition of this driver instance.\n"
		" Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAcquisitionStartStopBehaviour**.\n"
		"\n"
		" Notes: \n"
		" This property will become read-only while the device is open.\n"
		"\n"
		" This property is not supported by every device.\n"
		" Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"\n"
		" Not every device will offer the same options.\n"
		" Check for valid modes by reading the properties translation dictionary with\n"
		" the functions **mvIMPACT::acquire::PropertyIAcquisitionStartStopBehaviour::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::PropertyIAcquisitionStartStopBehaviour::getTranslationDictValue**.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" C++ offers the more efficient function **mvIMPACT::acquire::PropertyIAcquisitionStartStopBehaviour::getTranslationDict**\n"
		" in addition to the functions mentioned above.\n"
		" }\n"
		"\n"
		"Since: 1.12.11\n"
		""},
	 { "Device_HWUpdateResult_get", _wrap_Device_HWUpdateResult_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** defining user executed hardware update results.\n"
		"This property e.g. might contain the result of a user executed firmware update.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::THWUpdateResult**.\n"
		""},
	 { "Device_manufacturer_get", _wrap_Device_manufacturer_get, METH_O, "\n"
		"A string property **(read-only)** containing the name of the manufacturer of this device.\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"\n"
		"Since: 2.11.3\n"
		""},
	 { "Device_manufacturerSpecificInformation_get", _wrap_Device_manufacturerSpecificInformation_get, METH_O, "\n"
		"A string property **(read-only)** containing manufacturer specific information of this device.\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"\n"
		"Since: 2.18.3\n"
		""},
	 { "Device_desiredAccess_get", _wrap_Device_desiredAccess_get, METH_O, "\n"
		"An enumerated integer property that can be used to define the desired access to the device when opening it.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceAccessMode**.\n"
		"\n"
		"Notes: \n"
		"This property will become read-only while the device is open.\n"
		"\n"
		"This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "Device_grantedAccess_get", _wrap_Device_grantedAccess_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** that can be used to query the granted access to the device after an attempt to open it.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceAccessMode**.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "Device_autoNegotiatePacketSize_get", _wrap_Device_autoNegotiatePacketSize_get, METH_O, "\n"
		" An enumerated integer property which can be used to enable or disable the MTU auto negotiation of a GigE Vision device when opening it.\n"
		"If set to true, the driver will try to determine the max. possible packet size during init, which if successful will result in optimal performance.\n"
		" Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		" Notes: Once the device is in use (has been initialized) this property will become **(read-only)**. If this feature is disabled even before the device has been opened a\n"
		" firmware update is needed to use it when accessed via the ``mvGenTLProducer-lib``. When using a 3rd party GenTL producer to access the GigE Vision device this\n"
		" feature will not be available.\n"
		"\n"
		" This property might not be supported by every device. Therefore always call the function\n"
		" **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "Device_autoNegotiatePacketSizeMode_get", _wrap_Device_autoNegotiatePacketSizeMode_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** that can be used to define how the auto packet size negotiation for a GigE Vision device is handled.\n"
		"If set to **mvIMPACT::acquire::danpsmHighToLow** the MTU is automatically negotiated starting from the NICs current MTU down to a value supported by all components belonging to the network path\n"
		"(device, network interface card, switches, ...), if set to **mvIMPACT::acquire::danpsmLowToHigh** the negotiation starts with the small value tries larger values with each iteration until the\n"
		"optimal value has been found.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceAutoNegotiatePacketSizeMode**.\n"
		"\n"
		"Notes: Once the device is in use (has been initialized) this property will become **(read-only)**. When using a 3rd party GenTL producer to access the GigE Vision device this\n"
		"feature will not be available.\n"
		"\n"
		"This property might not be supported by every device. Therefore always call the function\n"
		"**mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "Device_licenseValid_get", _wrap_Device_licenseValid_get, METH_O, "\n"
		" A boolean property **(read-only)** that indicates if a device may be used with this SDK.\n"
		" All MATRIX VISION imaging and image capture devices may be used with this SDK without limitations. Third party devices might work as well but\n"
		" without an appropriate license that can be obtained from MATRIX VISION certain restrictions may apply.\n"
		"\n"
		" Notes: This property will only be supported by some drivers (those allowing the usage of third party devices). Therefore always call the function\n"
		" **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"\n"
		"See also: **mvIMPACT::acquire::Device::licenseDetails**\n"
		"\n"
		"Since: 2.46.0\n"
		""},
	 { "Device_licenseDetails_get", _wrap_Device_licenseDetails_get, METH_O, "\n"
		" A string property **(read-only)** that indicates why a device may be used with this SDK.\n"
		" This property holds information on why a device may be used with mvIMPACT Acquire.\n"
		"\n"
		" Notes: This property will only be supported by some drivers (those allowing the usage of third party devices). Therefore always call the function\n"
		" **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"\n"
		"See also: **mvIMPACT::acquire::Device::licenseValid**\n"
		"\n"
		"Since: 2.46.0\n"
		""},
	 { "Device_swigregister", Device_swigregister, METH_O, NULL},
	 { "Device_swiginit", Device_swiginit, METH_VARARGS, NULL},
	 { "new_DeviceManager", _wrap_new_DeviceManager, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Constructs a new **mvIMPACT::acquire::DeviceManager** object.\n"
		"If the construction of this object fails for some reason this constructor\n"
		"might throw an exception of type **mvIMPACT::acquire::ImpactAcquireException** or a type\n"
		"derived from this class.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Constructs a new **mvIMPACT::acquire::DeviceManager** object from an existing one.\n"
		"If the construction of this object fails for some reason this constructor\n"
		"might throw an exception of type **mvIMPACT::acquire::ImpactAcquireException** or a type\n"
		"derived from this class.\n"
		""},
	 { "delete_DeviceManager", _wrap_delete_DeviceManager, METH_O, "\n"
		"Class destructor.\n"
		"There always has to be at least one instance of the **DeviceManager** when\n"
		"the user still works with **mvIMPACT::acquire::Device** objects, as when the last instance to\n"
		"this object is destroyed all remaining **mvIMPACT::acquire::Device** objects will be closed\n"
		"automatically!\n"
		""},
	 { "DeviceManager_getVersionAsString", _wrap_DeviceManager_getVersionAsString, METH_O, "\n"
		" Returns a string containing the version number of the specified library.\n"
		" This function returns a string containing the version number of the specified library.\n"
		"\n"
		" The format of the string will be MAJOR.MINOR.RELEASE.BUILD.\n"
		" Since: 2.1.2\n"
		" :rtype: string\n"
		" :return: A pointer to an internal version string.\n"
		"\n"
		":type libraryQuery: int\n"
		":param libraryQuery: [in] Specifies the library to query information from.\n"
		""},
	 { "DeviceManager_getInternalHandle", _wrap_DeviceManager_getInternalHandle, METH_O, " Returns the internal handle to the device manager created via **DMR_Init()**."},
	 { "DeviceManager_changedCount", _wrap_DeviceManager_changedCount, METH_O, "\n"
		"Returns the current changed counter for the device list.\n"
		"This is a useful function to find out if the device list has been changed in any\n"
		"way. Such a change might be the appearance of a new USB device or a state change\n"
		"of any other device (e.g. when a USB device has been unplugged). Thus this function\n"
		"can be called periodically in order to maintain lists in GUI application for example.\n"
		"To find out the actual number of devices call **mvIMPACT::acquire::DeviceManager::deviceCount**.\n"
		":rtype: int\n"
		":return: The current changed counter for the device list.\n"
		""},
	 { "DeviceManager_deviceCount", _wrap_DeviceManager_deviceCount, METH_O, "\n"
		"Returns the number of devices currently present in the system.\n"
		"This function returns the number of devices currently detected in the system. A\n"
		"device once connected to the system while the device manager was running will remain\n"
		"in its list even if it's unplugged (then only its state will change). To detect\n"
		"changes in the **mvIMPACT::acquire::DeviceManager** objects list call the function\n"
		"**mvIMPACT::acquire::DeviceManager::changedCount**.\n"
		":rtype: int\n"
		":return: The number of devices detected in the current system.\n"
		""},
	 { "DeviceManager_updateDeviceList", _wrap_DeviceManager_updateDeviceList, METH_O, "\n"
		"Updates the internal device list.\n"
		"Most devices can't appear out of nowhere. For example a PCI device is\n"
		"either connected to the current system when the device manager is initialized\n"
		"or not but it will never appear at runtime after this instance of **mvIMPACT::acquire::DeviceManager**\n"
		"has been created.\n"
		"\n"
		"However certain device classes (e.g. network devices) might be connected to\n"
		"the system **AFTER** the device manager has been initialized. Some will announce themselves\n"
		"like e.g. USB devices, which will send a message to every application interested while others\n"
		"like e.g. network devices wont. In order not to\n"
		"pollute the network or bus with constant rescan messages no polling is done inside the driver.\n"
		"the user should call this function instead when looking for new devices. This can either be done in reasonable intervals or after\n"
		"it is known that a new device has been connected to the system.\n"
		"\n"
		"If new devices have been detected a subsequent call to **mvIMPACT::acquire::DeviceManager::deviceCount**\n"
		"will result in a higher value when compared to a previous call and **mvIMPACT::acquire::DeviceManager::changedCount**\n"
		"will contain a different value as well then (however this could also happen because a certain device related property did change\n"
		"its state).\n"
		"\n"
		"Notes: \n"
		"As long as a certain instance of a device manager is active, the devices once detected will **NOT**\n"
		"disappear from the list of devices even if they have been unplugged from the system. So the list\n"
		"of devices can only grow, but never gets shorter again until either the process terminates or the\n"
		"last instance of this class went out of scope. If a device has been unplugged, its **mvIMPACT::acquire::Device::state**\n"
		"property will change. If the application is interested in getting an instant notification when a\n"
		"device has been disconnected a callback can be registered on this property.\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"How to do this is explained here: 'Callback.cpp'\n"
		"}\n"
		""},
	 { "DeviceManager_getDevice", _wrap_DeviceManager_getDevice, METH_VARARGS, "\n"
		" Returns a pointer to a **mvIMPACT::acquire::Device** object.\n"
		" Returns a pointer to a **mvIMPACT::acquire::Device** object specifying the device found at the given\n"
		" index in the device managers internal list.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If the index is either equal or higher than the number of devices detected\n"
		" an STL out_of_range exception will be thrown.\n"
		" }\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::DeviceManager::deviceCount**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceBySerial**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByFamily**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**\n"
		" :rtype: :py:class:`Device`\n"
		" :return: \n"
		"     - A pointer to the device if *index* specifies a valid value.\n"
		"\n"
		"     - an exception will be raised otherwise.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the device to be returned.\n"
		""},
	 { "DeviceManager_getDeviceBySerial", _wrap_DeviceManager_getDeviceBySerial, METH_VARARGS, "\n"
		" Tries to locate a device via the serial number.\n"
		" This function tries to find a device by its serial number (or parts of this number).\n"
		" The user can specify only parts of the serial number and a wildcard. The **mvIMPACT::acquire::DeviceManager**\n"
		" object will then try to find that matches these parameters in its current list.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr;\n"
		"     // this will return a pointer to the second device with\n"
		"     // a serial number starting with 'SD' device found or 0\n"
		"     // if there are no 2 sample devices in the system\n"
		"     devMgr.getDeviceBySerial( \"SD*******\", 1, '*' );\n"
		"     // will return a pointer to the device with the serial\n"
		"     // number SD000001 if present or 0\n"
		"     devMgr.getDeviceBySerial( \"SD0000001\" );\n"
		"     // will return a pointer to the first device in the system\n"
		"     devMgr.getDeviceBySerial( \"*\", 0, '*' );\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr = new DeviceManager();\n"
		"     // this will return a pointer to the second device with\n"
		"     // a serial number starting with 'SD' device found or 0\n"
		"     // if there are no 2 sample devices in the system\n"
		"     devMgr.getDeviceBySerial( \"SD*******\", 1, '*' );\n"
		"     // will return a pointer to the device with the serial\n"
		"     // number SD000001 if present or 0\n"
		"     devMgr.getDeviceBySerial( \"SD0000001\" );\n"
		"     // will return a pointer to the first device in the system\n"
		"     devMgr.getDeviceBySerial( \"*\", 0, '*' );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     devMgr = acquire.DeviceManager()\n"
		"     # this will return a reference to the second device with\n"
		"     # a serial number starting with 'SD' device found or 0\n"
		"     # if there are no 2 sample devices in the system\n"
		"     devMgr.getDeviceBySerial(\"SD*******\", 1, '*')\n"
		"     # will return a reference to the device with the serial\n"
		"     # number SD000001 if present or 0\n"
		"     devMgr.getDeviceBySerial(\"SD0000001\")\n"
		"     # will return a reference to the first device in the system\n"
		"     devMgr.getDeviceBySerial(\"*\", 0, '*')\n"
		"}\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByFamily**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID**\n"
		" :rtype: :py:class:`Device`\n"
		" :return: \n"
		"     - A pointer to the device if found.\n"
		"\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type serial: string\n"
		":param serial: [in] The full serial number or the known parts of the serial number and wildcard characters.\n"
		":type devNr: int\n"
		":param devNr: [in] The number of the device to return (if there is more than one candidate).\n"
		":type wildcard: char\n"
		":param wildcard: [in] The character to ignore in *serial*.\n"
		""},
	 { "DeviceManager_getDeviceByFamily", _wrap_DeviceManager_getDeviceByFamily, METH_VARARGS, "\n"
		" Tries to locate a device via the family name.\n"
		" This function tries to find a device by its family (or parts of this family name).\n"
		" The user can specify only parts of the family name and a wildcard. The **mvIMPACT::acquire::DeviceManager**\n"
		" object will then try to find the device that matches these parameters in its current list.\n"
		" The family is the most general method of searching for a device apart from 'any device'.\n"
		" E.g. for a device the family name might be 'SampleDevice'\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr;\n"
		"     // this will return a pointer to the second 'SampleDevice'\n"
		"     // device found or 0 if there are no 2 'SampleDevice'\n"
		"     // devices in the system\n"
		"     devMgr.getDeviceByFamily( \"SampleD*\", 1, '*' );\n"
		"     // will return a pointer to the first device belonging\n"
		"     // to the 'SampleDevice' family if present or 0.\n"
		"     devMgr.getDeviceByFamily( \"SampleDevice\" );\n"
		"     // will return the first recognized device in the system\n"
		"     devMgr.getDeviceByFamily( \"*\", 0, '*' );\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr = new DeviceManager();\n"
		"     // this will return a pointer to the second 'SampleDevice'\n"
		"     // device found or 0 if there are no 2 'SampleDevice'\n"
		"     // devices in the system\n"
		"     devMgr.getDeviceByFamily( \"SampleD*\", 1, '*' );\n"
		"     // will return a pointer to the first device belonging\n"
		"     // to the 'SampleDevice' family if present or 0.\n"
		"     devMgr.getDeviceByFamily( \"SampleDevice\" );\n"
		"     // will return the first recognized device in the system\n"
		"     devMgr.getDeviceByFamily( \"*\", 0, '*' );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     devMgr = acquire.DeviceManager()\n"
		"     # this will return a reference to the second 'SampleDevice'\n"
		"     # device found or 0 if there are no 2 'SampleDevice'\n"
		"     # devices in the system\n"
		"     devMgr.getDeviceByFamily(\"SampleD*\", 1, '*')\n"
		"     # will return a reference to the first device belonging\n"
		"     # to the 'SampleDevice' family if present or 0.\n"
		"     devMgr.getDeviceByFamily(\"SampleDevice\")\n"
		"     # will return the first recognized device in the system\n"
		"     devMgr.getDeviceByFamily(\"*\", 0, '*')\n"
		"}\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceBySerial**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID**\n"
		" :rtype: :py:class:`Device`\n"
		" :return: \n"
		"     - A pointer to the device if found.\n"
		"\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type family: string\n"
		":param family: [in] The full family name of the requested device or known parts of it and wildcard characters.\n"
		":type devNr: int\n"
		":param devNr: [in] The number of the device to return (if there is more than one candidate).\n"
		":type wildcard: char\n"
		":param wildcard: [in] The character to ignore in *family*.\n"
		""},
	 { "DeviceManager_getDeviceByProduct", _wrap_DeviceManager_getDeviceByProduct, METH_VARARGS, "\n"
		" Tries to locate a device via the product name.\n"
		" This function tries to find a device by its product name (or parts of it).\n"
		" The user can specify only parts of the name and a wildcard. The **mvIMPACT::acquire::DeviceManager**\n"
		" object will then try to find the device that matches these parameters in its current list.\n"
		" The product name is a bit more specific than the family name, but less specific than\n"
		" the serial. For the 'SampleDevice' for example there might be different product names for different\n"
		" device types. This might e.g. be 'SampleDevice-G' for a grey version of the sample device and\n"
		" 'SampleDevice-C' for the color version of the sample device.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr;\n"
		"     // this will return a pointer to the second sample\n"
		"     // device of type 'G' found or 0 if there aren't\n"
		"     // two devices of this type in the system\n"
		"     devMgr.getDeviceByProduct( \"SampleDevice-G\", 1 );\n"
		"     // will return a pointer to the first device whose\n"
		"     // product string starts with 'SampleDev' or 0 if\n"
		"     // no such device can be found.\n"
		"     devMgr.getDeviceByProduct( \"SampleDev*\", 0, '*' );\n"
		"     // will return the first recognized device in the system\n"
		"     devMgr.getDeviceByProduct( \"*\", 0, '*' );\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		" DeviceManager devMgr = new DeviceManager();\n"
		" // this will return a pointer to the second sample\n"
		" // device of type 'G' found or 0 if there aren't\n"
		" // two devices of this type in the system\n"
		" devMgr.getDeviceByProduct( \"SampleDevice-G\", 1 );\n"
		" // will return a pointer to the first device whose\n"
		" // product string starts with 'SampleDev' or 0 if\n"
		" // no such device can be found.\n"
		" devMgr.getDeviceByProduct( \"SampleDev*\", 0, '*' );\n"
		" // will return the first recognized device in the system\n"
		" devMgr.getDeviceByProduct( \"*\", 0, '*' );\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     devMgr = acquire.DeviceManager()\n"
		"     # this will return a reference to the second sample\n"
		"     # device of type 'G' found or 0 if there aren't\n"
		"     # two devices of this type in the system\n"
		"     devMgr.getDeviceByProduct(\"SampleDevice-G\", 1)\n"
		"     # will return a reference to the first device whose\n"
		"     # product string starts with 'SampleDev' or 0 if\n"
		"     # no such device can be found.\n"
		"     devMgr.getDeviceByProduct(\"SampleDev*\", 0, '*')\n"
		"     # will return the first recognized device in the system\n"
		"     devMgr.getDeviceByProduct(\"*\", 0, '*')\n"
		"}\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceBySerial**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByFamily**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID**\n"
		" :rtype: :py:class:`Device`\n"
		" :return: \n"
		"     - A pointer to the device if found.\n"
		"\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type product: string\n"
		":param product: [in] The full product name of the requested device or known parts of it and wildcard characters.\n"
		":type devNr: int\n"
		":param devNr: [in] The number of the device to return (if there is more than one candidate).\n"
		":type wildcard: char\n"
		":param wildcard: [in] The character to ignore in *product*.\n"
		""},
	 { "DeviceManager_getDeviceByProductAndID", _wrap_DeviceManager_getDeviceByProductAndID, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Tries to locate a device via the product name and the device ID.\n"
		" This function behaves like\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**\n"
		" except that the second parameter now is interpreted as the device ID.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr;\n"
		"     // this will return a pointer to the sample device of\n"
		"     // type 'G' which has been assigned a device ID of '1'\n"
		"     // or 0 if there is no sample device with this ID in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDevice-G\", 1 );\n"
		"     // will return a pointer to the device whose product string\n"
		"     // starts with 'SampleDev' and whose device ID has been set\n"
		"     // to '0' or 0 if no such device can be found.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDev*\", 0, '*' );\n"
		"     // will return the first recognized device with an assigned\n"
		"     // device ID of '0' in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"*\", 0 );\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr = new DeviceManager();\n"
		"     // this will return a pointer to the sample device of\n"
		"     // type 'G' which has been assigned a device ID of '1'\n"
		"     // or 0 if there is no sample device with this ID in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDevice-G\", 1 );\n"
		"     // will return a pointer to the device whose product string\n"
		"     // starts with 'SampleDev' and whose device ID has been set\n"
		"     // to '0' or 0 if no such device can be found.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDev*\", 0, '*' );\n"
		"     // will return the first recognized device with an assigned\n"
		"     // device ID of '0' in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"*\", 0 );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     devMgr = acquire.DeviceManager()\n"
		"     # this will return a reference to the sample device of\n"
		"     # type 'G' which has been assigned a device ID of '1'\n"
		"     # or 0 if there is no sample device with this ID in the system.\n"
		"     devMgr.getDeviceByProductAndID(\"SampleDevice-G\", 1)\n"
		"     # will return a reference to the device whose product string\n"
		"     # starts with 'SampleDev' and whose device ID has been set\n"
		"     # to '0' or 0 if no such device can be found.\n"
		"     devMgr.getDeviceByProductAndID(\"SampleDev*\", 0, '*')\n"
		"     # will return the first recognized device with an assigned\n"
		"     # device ID of '0' in the system.\n"
		"     devMgr.getDeviceByProductAndID(\"*\", 0)\n"
		"}\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Device::deviceID**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByFamily**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceBySerial**,\n"
		"\n"
		" **mvIMPACT::acquire::Device::setID**\n"
		" :rtype: :py:class:`Device`\n"
		" :return: \n"
		"     - A pointer to the device if found.\n"
		"\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type product: string\n"
		":param product: [in] The full product name of the requested device or known parts of it and wildcard characters.\n"
		":type devID: int\n"
		":param devID: [in] The ID associated with this device.\n"
		":type wildcard: char\n"
		":param wildcard: [in] The character to ignore in *product*.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Tries to locate a device via the product name and the device ID.\n"
		" This function can be used to locate devices with a certain string identifier that has previously been written into a devices non-volatile\n"
		" memory. E.g. GenICam devices may support the ``DeviceUserID`` feature to assign a certain user defined name. A user defined\n"
		" name might be useful e.g. to access a device with a certain function without the need to worry about which device is it. You could\n"
		" e.g. have a ``barcodeReadingDevice`` and a ``monitorCamera``.\n"
		" This function behaves like **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**\n"
		" except that the second parameter now is interpreted as the device ID.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr;\n"
		"     // this will return a pointer to the sample device of\n"
		"     // type 'G' which has been assigned a device ID of 'abc'\n"
		"     // or 0 if there is no sample device with this ID in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDevice-G\", \"abc\" );\n"
		"     // will return a pointer to the device whose product string\n"
		"     // starts with 'SampleDev' and whose device ID has been set\n"
		"     // to 'def' or 0 if no such device can be found.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDev*\", \"def\", '*' );\n"
		"     // will return the first recognized device with an assigned\n"
		"     // device ID of 'anyString' in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"*\", \"anyString\" );\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr = new DeviceManager();\n"
		"     // this will return a pointer to the sample device of\n"
		"     // type 'G' which has been assigned a device ID of 'abc'\n"
		"     // or 0 if there is no sample device with this ID in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDevice-G\", \"abc\" );\n"
		"     // will return a pointer to the device whose product string\n"
		"     // starts with 'SampleDev' and whose device ID has been set\n"
		"     // to 'def' or 0 if no such device can be found.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDev*\", \"def\", '*' );\n"
		"     // will return the first recognized device with an assigned\n"
		"     // device ID of 'anyString' in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"*\", \"anyString\" );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     devMgr = acquire.DeviceManager()\n"
		"     # this will return a reference to the sample device of\n"
		"     # type 'G' which has been assigned a device ID of 'abc'\n"
		"     # or 0 if there is no sample device with this ID in the system.\n"
		"     devMgr.getDeviceByProductAndID(\"SampleDevice-G\", \"abc\")\n"
		"     # will return a reference to the device whose product string\n"
		"     # starts with 'SampleDev' and whose device ID has been set\n"
		"     # to 'def' or 0 if no such device can be found.\n"
		"     devMgr.getDeviceByProductAndID(\"SampleDev*\", \"def\", '*')\n"
		"     # will return the first recognized device with an assigned\n"
		"     # device ID of 'anyString' in the system.\n"
		"     devMgr.getDeviceByProductAndID(\"*\", \"anyString\")\n"
		"}\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Device::deviceID**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByFamily**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceBySerial**,\n"
		"\n"
		" **mvIMPACT::acquire::Device::setID**\n"
		" :rtype: :py:class:`Device`\n"
		" :return: \n"
		"     - A pointer to the device if found.\n"
		"\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type product: string\n"
		":param product: [in] The full product name of the requested device or known parts of it and wildcard characters.\n"
		":type devID: string\n"
		":param devID: [in] The device ID associated with this device.\n"
		":type wildcard: char\n"
		":param wildcard: [in] The character to ignore in *product*.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Tries to locate a device via the product name and the device ID.\n"
		" This function can be used to locate devices with a certain string identifier that has previously been written into a devices non-volatile\n"
		" memory. E.g. GenICam devices may support the ``DeviceUserID`` feature to assign a certain user defined name. A user defined\n"
		" name might be useful e.g. to access a device with a certain function without the need to worry about which device is it. You could\n"
		" e.g. have a ``barcodeReadingDevice`` and a ``monitorCamera``.\n"
		" This function behaves like **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**\n"
		" except that the second parameter now is interpreted as the device ID.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr;\n"
		"     // this will return a pointer to the sample device of\n"
		"     // type 'G' which has been assigned a device ID of 'abc'\n"
		"     // or 0 if there is no sample device with this ID in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDevice-G\", \"abc\" );\n"
		"     // will return a pointer to the device whose product string\n"
		"     // starts with 'SampleDev' and whose device ID has been set\n"
		"     // to 'def' or 0 if no such device can be found.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDev*\", \"def\", '*' );\n"
		"     // will return the first recognized device with an assigned\n"
		"     // device ID of 'anyString' in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"*\", \"anyString\" );\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     DeviceManager devMgr = new DeviceManager();\n"
		"     // this will return a pointer to the sample device of\n"
		"     // type 'G' which has been assigned a device ID of 'abc'\n"
		"     // or 0 if there is no sample device with this ID in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDevice-G\", \"abc\" );\n"
		"     // will return a pointer to the device whose product string\n"
		"     // starts with 'SampleDev' and whose device ID has been set\n"
		"     // to 'def' or 0 if no such device can be found.\n"
		"     devMgr.getDeviceByProductAndID( \"SampleDev*\", \"def\", '*' );\n"
		"     // will return the first recognized device with an assigned\n"
		"     // device ID of 'anyString' in the system.\n"
		"     devMgr.getDeviceByProductAndID( \"*\", \"anyString\" );\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     devMgr = acquire.DeviceManager()\n"
		"     # this will return a reference to the sample device of\n"
		"     # type 'G' which has been assigned a device ID of 'abc'\n"
		"     # or 0 if there is no sample device with this ID in the system.\n"
		"     devMgr.getDeviceByProductAndID(\"SampleDevice-G\", \"abc\")\n"
		"     # will return a reference to the device whose product string\n"
		"     # starts with 'SampleDev' and whose device ID has been set\n"
		"     # to 'def' or 0 if no such device can be found.\n"
		"     devMgr.getDeviceByProductAndID(\"SampleDev*\", \"def\", '*')\n"
		"     # will return the first recognized device with an assigned\n"
		"     # device ID of 'anyString' in the system.\n"
		"     devMgr.getDeviceByProductAndID(\"*\", \"anyString\")\n"
		"}\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Device::deviceID**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByFamily**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**,\n"
		"\n"
		" **mvIMPACT::acquire::DeviceManager::getDeviceBySerial**,\n"
		"\n"
		" **mvIMPACT::acquire::Device::setID**\n"
		" :rtype: :py:class:`Device`\n"
		" :return: \n"
		"     - A pointer to the device if found.\n"
		"\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type product: string\n"
		":param product: [in] The full product name of the requested device or known parts of it and wildcard characters.\n"
		":type devID: string\n"
		":param devID: [in] The device ID associated with this device.\n"
		":param wildcard: [in] The character to ignore in *product*.\n"
		""},
	 { "DeviceManager_closeAllDevices", _wrap_DeviceManager_closeAllDevices, METH_O, NULL},
	 { "DeviceManager___getitem__", _wrap_DeviceManager___getitem__, METH_VARARGS, NULL},
	 { "DeviceManager_swigregister", DeviceManager_swigregister, METH_O, NULL},
	 { "DeviceManager_swiginit", DeviceManager_swiginit, METH_VARARGS, NULL},
	 { "new_DeviceComponentLocator", _wrap_new_DeviceComponentLocator, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound locator.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new bound to the specified base list locator.\n"
		":type baselist: int\n"
		":param baselist: [in] A unique identifier to the base list from where to start to search for the search base.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new locator and searches the search base list.\n"
		":type baselist: int\n"
		":param baselist: [in] A unique identifier to the base list from where to start to search for the search base.\n"
		":type pathToSearchBase: string\n"
		":param pathToSearchBase: [in] The name or path ('/' separated) to the search base.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Constructs a new locator and bind the search base to the specified list type of the device.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type deviceListType: int\n"
		":param deviceListType: [in] The type list to locate\n"
		":type sublistName: string\n"
		":param sublistName: [in] A string that can contain the name of the list if there is more than one candidate (e.g. when looking for settings)\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Constructs a new locator and bind the search base to the specified list type of the device.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type deviceListType: int\n"
		":param deviceListType: [in] The type list to locate\n"
		":param sublistName: [in] A string that can contain the name of the list if there is more than one candidate (e.g. when looking for settings)\n"
		""},
	 { "DeviceComponentLocator_bindSearchBaseList", _wrap_DeviceComponentLocator_bindSearchBaseList, METH_VARARGS, "\n"
		" Assign a new search base to the locator.\n"
		" This new search base will be search starting from the base list specified.\n"
		" :rtype: int\n"
		" :return: The unique identifier of the new search base.\n"
		"\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type deviceListType: int\n"
		":param deviceListType: [in] The type list to locate\n"
		":type sublistName: string\n"
		":param sublistName: [in] The name or path to the search base.\n"
		""},
	 { "delete_DeviceComponentLocator", _wrap_delete_DeviceComponentLocator, METH_O, NULL},
	 { "DeviceComponentLocator_swigregister", DeviceComponentLocator_swigregister, METH_O, NULL},
	 { "DeviceComponentLocator_swiginit", DeviceComponentLocator_swiginit, METH_VARARGS, NULL},
	 { "new_ImageBufferDesc", _wrap_new_ImageBufferDesc, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new **mvIMPACT::acquire::ImageBufferDesc** from an existing one.\n"
		" The image buffer associated with this descriptor will not be copied! The internal\n"
		" data will be reference counted and changing this new object will also affect the\n"
		" original one. The internal data is freed when the last descriptor referencing the\n"
		" image is destroyed.\n"
		"\n"
		":type source: :py:class:`ImageBufferDesc`\n"
		":param source: [in] The source buffer descriptor.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::ImageBufferDesc** object with *channelCount* channel specific data elements.\n"
		" This constructor does **NOT** allocate memory for the actual pixel data but only for the\n"
		" a structure describing an image.\n"
		"\n"
		" When passing invalid values to this constructor (e.g. a negative value for ``channelCount)`` an\n"
		" exception will be thrown.\n"
		"\n"
		":type channelCount: int\n"
		":param channelCount: [in] The number of channel specific data elements to allocate memory for.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::ImageBufferDesc** object and allocates all memory needed.\n"
		" This constructor will allocate and handle a new and complete **ImageBuffer** object including\n"
		" memory for the pixel data for the given pixel format.\n"
		"\n"
		" The size(in bytes) of allocated pixel memory will depend on the *pixelFormat* as well as on the\n"
		" parameters *width* and *height*. **mvIMPACT::acquire::ImageBuffer::iSize** will return the\n"
		" amount of memory allocated for the buffer.\n"
		"\n"
		" When passing invalid values to this constructor (e.g. a negative value for ``height)`` an\n"
		" exception will be thrown.\n"
		"\n"
		":type pixelFormat: int\n"
		":param pixelFormat: [in] The desired pixel format for the new **mvIMPACT::acquire::ImageBuffer** object handled by this descriptor.\n"
		":type width: int\n"
		":param width: [in] The width of the new **mvIMPACT::acquire::ImageBuffer** object handled by this descriptor.\n"
		":type height: int\n"
		":param height: [in] The height of the new **mvIMPACT::acquire::ImageBuffer** object handled by this descriptor.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Constructs a new **mvIMPACT::acquire::ImageBufferDesc** object from a file and allocates all memory needed.\n"
		" This constructor will allocate and handle a new and complete **ImageBuffer** object including\n"
		" memory for the pixel data for the given pixel format. The buffer will be filled with the\n"
		" data from the file referenced by ``fileName``.\n"
		"\n"
		" Notes: \n"
		" Internally The FreeImage library (see 'legal notice' section) is used for this operation. If the library\n"
		" cannot be located in version 3.16.0 on the host system calling this constructor will fail and an\n"
		" exception will be thrown.\n"
		"\n"
		"Since: 2.23.0\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name of the file to load.\n"
		":type fileFormat: int\n"
		":param fileFormat: [in] The format of the file to load.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Constructs a new **mvIMPACT::acquire::ImageBufferDesc** object from a file and allocates all memory needed.\n"
		" This constructor will allocate and handle a new and complete **ImageBuffer** object including\n"
		" memory for the pixel data for the given pixel format. The buffer will be filled with the\n"
		" data from the file referenced by ``fileName``.\n"
		"\n"
		" Notes: \n"
		" Internally The FreeImage library (see 'legal notice' section) is used for this operation. If the library\n"
		" cannot be located in version 3.16.0 on the host system calling this constructor will fail and an\n"
		" exception will be thrown.\n"
		"\n"
		"Since: 2.23.0\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name of the file to load.\n"
		":param fileFormat: [in] The format of the file to load.\n"
		""},
	 { "delete_ImageBufferDesc", _wrap_delete_ImageBufferDesc, METH_O, " De-allocates all managed memory again when this is the last object referencing the image."},
	 { "ImageBufferDesc_clone", _wrap_ImageBufferDesc_clone, METH_O, "\n"
		"Returns a deep copy of the **mvIMPACT::acquire::ImageBuffer** object referenced by this descriptor.\n"
		"This function will create a deep copy of the **mvIMPACT::acquire::ImageBuffer** object referenced by this\n"
		"descriptor. Afterwards modifying one of the images will **NOT** influence the other one.\n"
		"\n"
		":rtype: :py:class:`ImageBufferDesc`\n"
		":return: A deep copy of the **mvIMPACT::acquire::ImageBuffer** object referenced by this descriptor.\n"
		""},
	 { "ImageBufferDesc_copy", _wrap_ImageBufferDesc_copy, METH_VARARGS, "\n"
		" Returns a deep copy of the data buffer of the underlying **mvIMPACT::acquire::ImageBuffer** object referenced by this descriptor.\n"
		" This function will create a deep copy of the data buffer of the **mvIMPACT::acquire::ImageBuffer** object referenced by this\n"
		" descriptor. Afterwards modifying one of the buffers will **NOT** influence the other one.\n"
		"\n"
		"Since: 2.36.0\n"
		" :rtype: int\n"
		" :return: The buffer size needed for ``pDst`` if ``dstSize`` was too small or the size used if the operation was successful.\n"
		"\n"
		":type pDst: string\n"
		":param pDst: A pointer to the buffer to copy the data into. Can be 0 if just the size needed shall be queried.\n"
		":type dstSize: int\n"
		":param dstSize: The size of the buffer pointed to by ``pDst``. Is 'don't care' if just the size needed shall be queried.\n"
		""},
	 { "ImageBufferDesc_getBuffer", _wrap_ImageBufferDesc_getBuffer, METH_O, "\n"
		"Grants access to the underlying **mvIMPACT::acquire::ImageBuffer** structure managed by this object.\n"
		":rtype: :py:class:`ImageBuffer`\n"
		":return: A pointer to the **mvIMPACT::acquire::ImageBuffer** object referenced by this descriptor.\n"
		""},
	 { "ImageBufferDesc_save", _wrap_ImageBufferDesc_save, METH_VARARGS, "\n"
		" Stores the complete data of one **ImageBuffer** structure into a file.\n"
		" This function stores the image described by a **mvIMPACT::acquire::ImageBuffer** structure pointed to by the ``pBuffer`` variable\n"
		" into a file.\n"
		"\n"
		" Notes: \n"
		" Internally The FreeImage library (see 'legal notice' section) is used for this operation. If the library\n"
		" cannot be located in version 3.16.0 on the host system calling this function will fail.\n"
		"\n"
		"Since: 2.23.0\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DMR_LIBRARY_NOT_FOUND** if the required version of the FreeImage library could not be located on the host system.\n"
		"     - **mvIMPACT::acquire::DEV_UNSUPPORTED_PARAMETER** if a pixel format has been passed to the function that is not supported by the internal algorithms.\n"
		"     - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** if a pixel format has been passed to the function that is not supported by the FreeImage library.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The full path of the file to create.\n"
		":type format: int\n"
		":param format: [in] The format of the file to be created. If this parameter is set to **mvIMPACT::acquire::iffAuto** make sure to specify a proper file extension.\n"
		""},
	 { "ImageBufferDesc_swigregister", ImageBufferDesc_swigregister, METH_O, NULL},
	 { "ImageBufferDesc_swiginit", ImageBufferDesc_swiginit, METH_VARARGS, NULL},
	 { "delete_ComponentCollection", _wrap_delete_ComponentCollection, METH_O, NULL},
	 { "ComponentCollection_hObj", _wrap_ComponentCollection_hObj, METH_O, "\n"
		"Returns a unique identifier for the component collection referenced by this object.\n"
		"This handle will always reference an object of type **mvIMPACT::acquire::ComponentList**.\n"
		":rtype: int\n"
		":return: A unique identifier for the component referenced by this object.\n"
		""},
	 { "ComponentCollection_restoreDefault", _wrap_ComponentCollection_restoreDefault, METH_O, "\n"
		"Restores the default for every component of this collection.\n"
		"Calling this function will restore the default value for every component\n"
		"belonging to this collection.\n"
		"\n"
		"Notes: The caller must have the right to modify the component. Otherwise\n"
		"an exception will be thrown.\n"
		"\n"
		":rtype: :py:class:`ComponentCollection`\n"
		":return: A const reference to the component.\n"
		""},
	 { "ComponentCollection_swigregister", ComponentCollection_swigregister, METH_O, NULL},
	 { "BufferPart_getImageBufferDesc", _wrap_BufferPart_getImageBufferDesc, METH_O, "\n"
		"Returns a const reference to the image buffer descriptor of this buffer part.\n"
		"This function returns a const reference to the **mvIMPACT::acquire::ImageBufferDesc** associated\n"
		"with this **mvIMPACT::acquire::BufferPart**.\n"
		"\n"
		"\n"
		"Please do **NEVER** work with old references to this structure. So do **NOT** store this reference in\n"
		"some variable to use it for the evaluation of the next **mvIMPACT::acquire::BufferPart** object as well,\n"
		"as this will not work. Whenever **mvIMPACT::acquire::BufferPart::getImageBufferDesc** is called the function\n"
		"will make sure that the data in the returned structure is up to date while when working with\n"
		"an old reference to the **mvIMPACT::acquire::ImageBufferDesc** structure the containing data might refer\n"
		"to a previous result or even worse invalid memory locations. This reference will remain valid until an\n"
		"application calls **mvIMPACT::acquire::Request::unlock** for the corresponding request.\n"
		""},
	 { "BufferPart_address_get", _wrap_BufferPart_address_get, METH_O, "\n"
		" A pointer property **(read-only)** containing the start address of this buffer part.\n"
		"See remarks under **mvIMPACT::acquire::Request::imageData**. Most of the information provided there\n"
		"will be valid for this property as well.\n"
		""},
	 { "BufferPart_dataSize_get", _wrap_BufferPart_dataSize_get, METH_O, "\n"
		" A 64-bit integer property **(read-only)** containing the size (in bytes) of this buffer part.\n"
		"See remarks under **mvIMPACT::acquire::Request::imageData**. Most of the information provided there\n"
		"will be valid for this property as well.\n"
		""},
	 { "BufferPart_dataType_get", _wrap_BufferPart_dataType_get, METH_O, "\n"
		"An enumerated 64-bit integer property **(read-only)** containing the data type of this buffer part.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBufferPartDataType**.\n"
		""},
	 { "BufferPart_pixelFormat_get", _wrap_BufferPart_pixelFormat_get, METH_O, "\n"
		"An enumerated integer property defining the pixel format of this buffer part.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageBufferPixelFormat**.\n"
		""},
	 { "BufferPart_width_get", _wrap_BufferPart_width_get, METH_O, " A 64-bit integer property **(read-only)** containing the width of the buffer part in pixels."},
	 { "BufferPart_height_get", _wrap_BufferPart_height_get, METH_O, " A 64-bit integer property **(read-only)** containing the height of the buffer part in pixels."},
	 { "BufferPart_offsetX_get", _wrap_BufferPart_offsetX_get, METH_O, " A 64-bit integer property **(read-only)** containing the X-offset of the buffer part in pixels."},
	 { "BufferPart_offsetY_get", _wrap_BufferPart_offsetY_get, METH_O, " A 64-bit integer property **(read-only)** containing the Y-offset of the buffer part in pixels."},
	 { "BufferPart_paddingX_get", _wrap_BufferPart_paddingX_get, METH_O, " A 64-bit integer property **(read-only)** containing the number of padding bytes in X direction of the buffer part."},
	 { "BufferPart_bytesPerPixel_get", _wrap_BufferPart_bytesPerPixel_get, METH_O, " A 64-bit integer property **(read-only)** containing the number of bytes per pixel in this buffer part."},
	 { "BufferPart_bayerMosaicParity_get", _wrap_BufferPart_bayerMosaicParity_get, METH_O, "\n"
		"An enumerated 64-bit integer property **(read-only)** containing the Bayer parity of this buffer part.\n"
		"If the current buffer part does not contain Bayer data, this value will be **mvIMPACT::acquire::bmpUndefined**.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.\n"
		""},
	 { "BufferPart_channelCount_get", _wrap_BufferPart_channelCount_get, METH_O, "\n"
		"A 64-bit integer property **(read-only)** containing the number of channels this buffer part consists of.\n"
		"For an RGB image this value e.g. would be 3. This value also defines how many parameters are stored by the properties\n"
		"**mvIMPACT::acquire::BufferPart::pixelPitch**,\n"
		"\n"
		"**mvIMPACT::acquire::BufferPart::linePitch**,\n"
		"\n"
		"**mvIMPACT::acquire::BufferPart::channelBitDepth**,\n"
		"\n"
		"**mvIMPACT::acquire::BufferPart::channelDesc** and\n"
		"\n"
		"**mvIMPACT::acquire::BufferPart::channelOffset**.\n"
		"\n"
		"If e.g. the channel count is 3 a call like bufferPart.channelOffset.read( 2 ) would return the channel offset of\n"
		"channel 3 (as calls to the read functions of properties are '0' based).\n"
		""},
	 { "BufferPart_channelDesc_get", _wrap_BufferPart_channelDesc_get, METH_O, "\n"
		" A string property **(read-only)** containing the string descriptors of each channel belonging to the current buffer part.\n"
		"See remarks under **mvIMPACT::acquire::Request::imageChannelDesc**. Most of the information provided there\n"
		"will be valid for this property as well.\n"
		""},
	 { "BufferPart_pixelPitch_get", _wrap_BufferPart_pixelPitch_get, METH_O, "\n"
		"A 64-bit integer property **(read-only)** containing the offset (in bytes) to the next pixel of the specified channel of this buffer part.\n"
		"Notes: \n"
		"This property will store *channelCount* values. These can be queried one by one using the *index* parameter of the function\n"
		"**mvIMPACT::acquire::PropertyI64::read()** or in a single call by using the overloaded *read* function accepting a reference to a\n"
		"vector.\n"
		""},
	 { "BufferPart_linePitch_get", _wrap_BufferPart_linePitch_get, METH_O, "\n"
		"A 64-bit integer property **(read-only)** containing the offset (in bytes) to the next line of each channel belonging to the current buffer part.\n"
		"Notes: \n"
		"This property will store *channelCount* values. These can be queried one by one using the *index* parameter of the function\n"
		"**mvIMPACT::acquire::PropertyI64::read()** or in a single call by using the overloaded *read* function accepting a reference to a\n"
		"vector.\n"
		""},
	 { "BufferPart_channelBitDepth_get", _wrap_BufferPart_channelBitDepth_get, METH_O, "\n"
		"A 64-bit integer property **(read-only)** containing the number of effective bits stored in each channel belonging to the current buffer part.\n"
		"Notes: \n"
		"This property will store *channelCount* values. These can be queried one by one using the *index* parameter of the function\n"
		"**mvIMPACT::acquire::PropertyI64::read()** or in a single call by using the overloaded *read* function accepting a reference to a\n"
		"vector.\n"
		""},
	 { "BufferPart_channelOffset_get", _wrap_BufferPart_channelOffset_get, METH_O, "\n"
		" A 64-bit integer property **(read-only)** containing the offset (in bytes) to each channel belonging to the current buffer part relative to the address contained in **mvIMPACT::acquire::BufferPart::address**.\n"
		"Notes: \n"
		"This property will store *channelCount* values. These can be queried one by one using the *index* parameter of the function\n"
		"**mvIMPACT::acquire::PropertyI64::read()** or in a single call by using the overloaded *read* function accepting a reference to a\n"
		"vector.\n"
		""},
	 { "BufferPart_sourceID_get", _wrap_BufferPart_sourceID_get, METH_O, "\n"
		" Identifier allowing to group data parts belonging to the same source (usually corresponding with the SourceSelector/ChunkSourceID features from SFNC).\n"
		"Parts marked with the same source_id can be pixel mapped together. Parts carrying data from different ROI's of the same source would typically be marked with the\n"
		"same source_id. It is not mandatory that source_id's within a given buffer make a contiguous sequence of numbers starting with zero.\n"
		"Notes: \n"
		"For example with a dual-source 3D camera, the buffer can contain data parts carrying the 3D data and Confidence data corresponding to both\n"
		"of the two different sources. In this case the source ID helps to match the 3D and Confidence parts belonging together.\n"
		""},
	 { "BufferPart_regionID_get", _wrap_BufferPart_regionID_get, METH_O, "\n"
		" Identifier allowing to group data parts belonging to the same region (usually corresponding with the RegionSelector/ChunkRegionID features from SFNC).\n"
		"Parts marked with the same region_id can be pixel mapped together. Parts carrying data from different ROI's of the same source would typically be marked with the\n"
		"same source_id but with different region_ids.\n"
		"\n"
		"Since: 2.50.0\n"
		""},
	 { "BufferPart_groupID_get", _wrap_BufferPart_groupID_get, METH_O, "\n"
		" Identifier allowing to group data parts having the same purpose (usually corresponding with the ComponentSelector feature from SFNC).\n"
		"Since: 2.50.0\n"
		""},
	 { "delete_BufferPart", _wrap_delete_BufferPart, METH_O, NULL},
	 { "BufferPart_swigregister", BufferPart_swigregister, METH_O, NULL},
	 { "new_Request", _wrap_new_Request, METH_VARARGS, NULL},
	 { "delete_Request", _wrap_delete_Request, METH_O, NULL},
	 { "Request_getComponentLocator", _wrap_Request_getComponentLocator, METH_O, "\n"
		" Returns a component locator for this request.\n"
		"This will allow to write custom feature bind operations.\n"
		"\n"
		" Since: 1.12.68\n"
		":rtype: :py:class:`DeviceComponentLocator`\n"
		":return: A component locator for this request.\n"
		""},
	 { "Request_getBufferPartCount", _wrap_Request_getBufferPartCount, METH_O, "\n"
		" Returns the number of buffer parts currently associated with this request.\n"
		"Certain device drivers are able to deliver multiple buffer part within a single request object.\n"
		"See also: \n"
		"'ImageAcquisition_MultiPart'\n"
		"Since: 2.20.0\n"
		":rtype: int\n"
		":return: The number of buffer parts currently associated with this request. This might be zero in case the device\n"
		"    driver delivers a ``standard`` data stream. It might also be 1 for special data formats such as JPEG, which must be handled\n"
		"    differently from an image describing properties perspective.\n"
		""},
	 { "Request_getBufferPart", _wrap_Request_getBufferPart, METH_VARARGS, "\n"
		" Returns a reference to a buffer part descriptor of this request.\n"
		" This function returns a reference to a **mvIMPACT::acquire::BufferPart** at index ``index`` associated\n"
		" with this **mvIMPACT::acquire::Request**.\n"
		"\n"
		"\n"
		" Please do **NEVER** work with old references to this class. So do **NOT** store this reference in\n"
		" some variable to use it for the evaluation of the next **mvIMPACT::acquire::Request** object as well,\n"
		" as this might not work because the buffer layout might have changed. Whenever **mvIMPACT::acquire::Request::getBufferPart**\n"
		" is called the function will make sure that the data in the returned structure is up to date while when working with\n"
		" an old reference to the **mvIMPACT::acquire::BufferPart** structure the containing data might refer\n"
		" to a previous result or worse an invalid memory location. This reference will remain valid until an\n"
		" application calls **mvIMPACT::acquire::Request::unlock** for the corresponding request.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::Request::getBufferPartCount**\n"
		"\n"
		"'ImageAcquisition_MultiPart'\n"
		"\n"
		"Since: 2.20.0\n"
		":rtype: :py:class:`BufferPart`\n"
		":return: A reference to the buffer part defined by ``index``\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the buffer part to return\n"
		""},
	 { "Request_getName", _wrap_Request_getName, METH_O, "\n"
		" Returns the name associated with this request.\n"
		"Since: 2.32.0\n"
		""},
	 { "Request_getNumber", _wrap_Request_getNumber, METH_O, " Returns the number associated with this request."},
	 { "Request_getImageBufferDesc", _wrap_Request_getImageBufferDesc, METH_O, "\n"
		"Returns a const reference to the image buffer descriptor of this request.\n"
		"This function returns a const reference to the **mvIMPACT::acquire::ImageBufferDesc** associated\n"
		"with this **mvIMPACT::acquire::Request**.\n"
		"\n"
		"\n"
		"Please do **NEVER** work with old references to this structure. So do **NOT** store this reference in\n"
		"some variable to use it for the evaluation of the next **mvIMPACT::acquire::Request** object as well,\n"
		"as this will not work. Whenever **mvIMPACT::acquire::Request::getImageBufferDesc** is called the function\n"
		"will make sure that the data in the returned structure is up to date while when working with\n"
		"an old reference to the **mvIMPACT::acquire::ImageBufferDesc** structure the containing data might refer\n"
		"to a previous result.\n"
		""},
	 { "Request_getInfoIterator", _wrap_Request_getInfoIterator, METH_O, "\n"
		" Returns an iterator for iterating inside the info list of the request.\n"
		" This can be useful when custom or device specific information has been attached to the request\n"
		" object that wasn't known at compile time.\n"
		"\n"
		"It allows to write code like this:\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,\n"
		"     // 'nr' is assumed to be a valid request number returned from a previous call to\n"
		"     // mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor()\n"
		"     const Request* pRequest = fi.getRequest( nr );\n"
		"     if( pRequest )\n"
		"     {\n"
		"       Component it(pRequest-getInfoIterator());\n"
		"       std::mapstd::string, std::string m;\n"
		"       while( it.isValid() )\n"
		"       {\n"
		"         // collect all entries that are properties and store their current name and value in a map\n"
		"         if( it.isProp()  it.isVisible() )\n"
		"         {\n"
		"           Property prop( it );\n"
		"           m.insert( std::make_pair( prop.name(), prop.readS() ) );\n"
		"         }\n"
		"         ++it;\n"
		"       }\n"
		"       // Here you can work with the information you just obtained\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     import java.util.Hashtable;\n"
		"\n"
		"     // ...\n"
		"\n"
		"     Component it = pRequest.getInfoIterator();\n"
		"     HashtableString, String m = new HashtableString, String();\n"
		"     while( it.isValid() )\n"
		"     {\n"
		"       // collect all entries that are properties and store their current name and value in a hash table\n"
		"       if( it.isProp()  it.isVisible() )\n"
		"       {\n"
		"         Property prop = new Property( it.hObj() );\n"
		"         m.put( prop.name(), prop.readS() );\n"
		"       }\n"
		"       it = it.nextSibling();\n"
		"     }\n"
		"     // Here you can work with the information you just obtained\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     # 'fi' is assumed to be a valid instance of acquire.FunctionInterface,\n"
		"     # 'nr' is assumed to be a valid request number returned from a previous call to\n"
		"     # acquire.FunctionInterface.imageRequestWaitFor()\n"
		"     pRequest = fi.getRequest(requestNr)\n"
		"     if pRequest:\n"
		"         it = pRequest.getInfoIterator()\n"
		"         props = {None:None}\n"
		"         while it.isValid:\n"
		"             if it.isProp and it.isVisible:\n"
		"                 prop = acquire.Property(it.hObj())\n"
		"                 props[prop.name()] = prop.readS()\n"
		"             it = it.nextSibling()\n"
		"         # Here you can work with the information you just obtained\n"
		"}\n"
		":rtype: :py:class:`Component`\n"
		":return: \n"
		"    An iterator for iterating inside the info list of the request.\n"
		""},
	 { "Request_getImageProcessingResultsIterator", _wrap_Request_getImageProcessingResultsIterator, METH_O, "\n"
		" Returns an iterator for iterating inside the info/imageProcessingResults list of the request.\n"
		" This can be useful when custom or device specific algorithms have been applied to the request\n"
		" object that weren't known at compile time.\n"
		"\n"
		" For a code example please refer to the documentation of **mvIMPACT::acquire::Request::getInfoIterator**\n"
		" See also: \n"
		" **mvIMPACT::acquire::Request::getInfoIterator**\n"
		"\n"
		"\n"
		"Since: 2.14.0\n"
		"\n"
		":rtype: :py:class:`Component`\n"
		":return: \n"
		"    An iterator for iterating inside the info/imageProcessingResults list of the request.\n"
		""},
	 { "Request_getHasProcessingBeenSkipped", _wrap_Request_getHasProcessingBeenSkipped, METH_O, "\n"
		"Checks if image processing that was set up for this request has been skipped for performance reasons.\n"
		"If **mvIMPACT::acquire::Device::userControlledImageProcessingEnable** is set to **mvIMPACT::acquire::bTrue** and\n"
		"**mvIMPACT::acquire::SystemSettings::imageProcessingMode** is set to  **mvIMPACT::acquire::ipmProcessLatestOnly**\n"
		"this function can be used to check if at least one algorithm has been skipped because of a lack of processing time.\n"
		"See also: \n"
		"**mvIMPACT::acquire::Device::userControlledImageProcessingEnable**,\n"
		"\n"
		"**mvIMPACT::acquire::SystemSettings::imageProcessingMode**\n"
		"\n"
		"\n"
		"Since: 2.14.0\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if at least one internal algorithm has been skipped.\n"
		"    - false otherwise.\n"
		""},
	 { "Request_getChunkCounterCount", _wrap_Request_getChunkCounterCount, METH_O, "\n"
		"Returns the number of counter values that can be returned as part of the additional data of the buffer containing the request data.\n"
		"A device may support a large number of counters even though just a few of them or none is configured\n"
		"for counting. In such a case situation when switching on the transmission of the counter values\n"
		"at the time of the internal frame start event will allow to access the number of counters returned\n"
		"by this function but then the data in these counters of course will be meaningless.\n"
		"\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		"Since: 2.0.15\n"
		":rtype: int\n"
		":return: \n"
		"    The number of counter values that can be returned as part of the additional data of the buffer containing the request data.\n"
		""},
	 { "Request_getChunkCounterValue", _wrap_Request_getChunkCounterValue, METH_VARARGS, "\n"
		" Returns a 64 bit integer property **(read-only)** defining the selected counter value at the time of the internal frame start event for this request.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *index* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" Notes: \n"
		" For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		" Since: 2.0.15\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the counter to return\n"
		""},
	 { "Request_getChunkTimerCount", _wrap_Request_getChunkTimerCount, METH_O, "\n"
		"Returns the number of timer values that can be returned as part of the additional data of the buffer containing the request data.\n"
		"A device may support a large number of timers even though just a few of them or none is configured\n"
		"to run. In such a case situation when switching on the transmission of the timer values\n"
		"at the time of the internal frame start event will allow to access the number of timers returned\n"
		"by this function but then the data in these timers of course will be meaningless.\n"
		"\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		"Since: 2.0.15\n"
		""},
	 { "Request_getChunkTimerValue", _wrap_Request_getChunkTimerValue, METH_VARARGS, "\n"
		" Returns a floating point property **(read-only)** defining the selected timer value at the time of the internal frame start event for this request.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *index* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" Notes: \n"
		" For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		" Since: 2.0.15\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the timer to return\n"
		""},
	 { "Request_getChunkGainCount", _wrap_Request_getChunkGainCount, METH_O, "\n"
		"Returns the number of gain values that can be returned as part of the additional data of the buffer containing the request data.\n"
		"A device may support a large number of gains even though just a few of them or none is configured\n"
		"to run. In such a case situation when switching on the transmission of the gain values\n"
		"at the time of the internal frame start event will allow to access the number of gains returned\n"
		"by this function but then the data in these gains of course will be meaningless.\n"
		"\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		"Since: 2.17.3\n"
		""},
	 { "Request_getChunkGain", _wrap_Request_getChunkGain, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns a floating point property **(read-only)** defining the selected gain value at the time of the internal frame start event for this request.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *index* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" Notes: \n"
		" For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		" Since: 2.17.3\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the gain to return\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns a floating point property **(read-only)** defining the selected gain value at the time of the internal frame start event for this request.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *name* is invalid(not a valid gain to select) a **mvIMPACT::acquire::EInvalidInputParameter** exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" Notes: \n"
		" For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		" Since: 2.17.3\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name of the gain to return (as selected by **mvIMPACT::acquire::GenICam::AnalogControl::gainSelector**)\n"
		""},
	 { "Request_getIsOK", _wrap_Request_getIsOK, METH_O, "\n"
		" Convenience function to check if a request has been processed successfully.\n"
		"This is just a nicer way of checking the value of the *requestResult* property.\n"
		"It allows to write code like this:\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,\n"
		"     // 'nr' is assumed to be a valid request number returned from a previous call to\n"
		"     // mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor()\n"
		"     const Request* pRequest = fi.getRequest( nr );\n"
		"     if( pRequest-isOK() )\n"
		"     {\n"
		"       // do something\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,\n"
		"     // 'nr' is assumed to be a valid request number returned from a previous call to\n"
		"     // mvIMPACT.acquire.FunctionInterface.imageRequestWaitFor()\n"
		"     Request pRequest = fi.getRequest( nr );\n"
		"     if( pRequest.isOK() )\n"
		"     {\n"
		"       // do something\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     # 'fi' is assumed to be a valid instance of acquire.FunctionInterface,\n"
		"     # 'nr' is assumed to be a valid request number returned from a previous call to\n"
		"     # acquire.FunctionInterface.imageRequestWaitFor()\n"
		"     pRequest = fi.getRequest(nr)\n"
		"     if pRequest.isOK:\n"
		"       # do something\n"
		"}\n"
		"\n"
		"Instead if this:\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,\n"
		"     // 'nr' is assumed to be a valid request number returned from a previous call to\n"
		"     // mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor()\n"
		"     const Request* pRequest = fi.getRequest( nr );\n"
		"     if( pRequest-requestResult.read() == rrOK )\n"
		"     {\n"
		"       // do something\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,\n"
		"     // 'nr' is assumed to be a valid request number returned from a previous call to\n"
		"     // mvIMPACT.acquire.FunctionInterface.imageRequestWaitFor()\n"
		"     Request pRequest = fi.getRequest( nr );\n"
		"     if( pRequest.getRequestResult().read() == TRequestResult.rrOK )\n"
		"     {\n"
		"       // do something\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     # 'fi' is assumed to be a valid instance of acquire.FunctionInterface,\n"
		"     # 'nr' is assumed to be a valid request number returned from a previous call to\n"
		"     # acquire.FunctionInterface.imageRequestWaitFor()\n"
		"     pRequest = fi.getRequest(nr)\n"
		"     if(pRequest.requestResult.read() == acquire.rrOK):\n"
		"       # do something\n"
		"}\n"
		"\n"
		" Since: 1.12.63\n"
		"\n"
		" :rtype: boolean\n"
		" :return: \n"
		"     - true if the request has been processed successfully.\n"
		"     - false otherwise.\n"
		""},
	 { "Request_configure", _wrap_Request_configure, METH_O, "\n"
		" Sets a request into configuration mode.\n"
		" In configuration mode certain properties like **mvIMPACT::acquire::Request::imageData**,\n"
		" **mvIMPACT::acquire::Request::imageSize**, **mvIMPACT::acquire::Request::imageMemoryMode**\n"
		" of a request object can be modified. This can be used to configure one or more requests\n"
		" to use a user supplied memory. To use only a subset of the **mvIMPACT::acquire::Request**\n"
		" objects available the **mvIMPACT::acquire::ImageRequestControl::requestToUse** feature\n"
		" can be used.\n"
		"\n"
		" Only requests that are currently not used by the driver and are not locked\n"
		" because they contain image data that hasn't been processed can be set into\n"
		" configuration mode.\n"
		"\n"
		" Notes: \n"
		" Instead of calling this function directly for most cases it is much more convenient to use\n"
		" the functions **mvIMPACT::acquire::Request::attachUserBuffer** and **mvIMPACT::acquire::Request::detachUserBuffer**\n"
		" instead.\n"
		"\n"
		" User supplied buffers must follow the alignment and size requirements reported by versions of the\n"
		" function **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout**. Calling\n"
		" a version of this function will return all the information required to allocate buffers that\n"
		" can be used to capture data for the specified settings.\n"
		"\n"
		" When allocating memory on the heap, the complete buffer size is needed which is calculated like\n"
		" this:\n"
		"\n"
		" **size + alignment**\n"
		"\n"
		"\n"
		" The address passed to the request object must be aligned already!\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     Device* pDev = getDevicePointerFromSomewhere()\n"
		"     FunctionInterface fi(pDev);\n"
		"     Request* pRequest = fi.getRequest( 0 );\n"
		"     // the buffer assigned to the request object must be aligned accordingly\n"
		"     // the size of the user supplied buffer MUST NOT include the additional size\n"
		"     // caused by the alignment\n"
		"     if( pRequest-attachUserBuffer( getAlignedMemoryPtr(), getAlignedMemorySize() ) ) == DMR_NO_ERROR )\n"
		"     {\n"
		"       ImageRequestControl irc(pDev);\n"
		"       irc.requestToUse.write( 0 ); // use the buffer just configured for the next image request\n"
		"       // now the next image will be captured into the user supplied memory\n"
		"       fi.imageRequestSingle( irc ); // this will send request '0' to the driver\n"
		"       // wait for the buffer. Once it has been returned by the driver AND the user buffer shall no\n"
		"       // longer be used call\n"
		"       if( pRequest-detachUserBuffer() != DMR_NO_ERROR )\n"
		"       {\n"
		"         // handle error\n"
		"       }\n"
		"       // now this request will use internal memory again.\n"
		"     }\n"
		"     else\n"
		"     {\n"
		"        // handle error\n"
		"     }\n"
		" }\n"
		"\n"
		" A request that is in configuration mode can't be sent to the driver for acquisition until\n"
		" **mvIMPACT::acquire::Request::unlock** or **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock** has been called again.\n"
		" By using **mvIMPACT::acquire::Request::attachUserBuffer** and **mvIMPACT::acquire::Request::detachUserBuffer** this locking\n"
		" and unlocking is done internally thus the application does not need to worry about this.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::attachUserBuffer**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::detachUserBuffer**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestReset**\n"
		"\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "Request_save", _wrap_Request_save, METH_VARARGS, "\n"
		" Stores the image described by this request into a file.\n"
		" This function stores the image described by this request into a file.\n"
		"\n"
		" Notes: \n"
		" Internally The FreeImage library (see 'legal notice' section) is used for this operation. If the library\n"
		" cannot be located in version 3.16.0 on the host system calling this function will fail.\n"
		"\n"
		"Since: 2.23.0\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DMR_LIBRARY_NOT_FOUND** if the required version of the FreeImage library could not be located on the host system.\n"
		"     - **mvIMPACT::acquire::DEV_UNSUPPORTED_PARAMETER** if a pixel format has been passed to the function that is not supported by the internal algorithms.\n"
		"     - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** if a pixel format has been passed to the function that is not supported by the FreeImage library.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The full path of the file to create.\n"
		":type format: int\n"
		":param format: [in] The format of the file to be created. If this parameter is set to **mvIMPACT::acquire::iffAuto** make sure to specify a proper file extension.\n"
		""},
	 { "Request_unlock", _wrap_Request_unlock, METH_O, "\n"
		"Unlocks the request for the driver again.\n"
		"\n"
		"To ensure that no image data is overwritten by another image request while the user still\n"
		"deals with the image from a previous acquisition each image buffer will be locked by the driver when\n"
		"it is returned to the user by a call to **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**.\n"
		"No new image will be captured into the same buffer until the user unlocks the buffer again\n"
		"by calling **mvIMPACT::acquire::Request::unlock** or **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**.\n"
		"\n"
		"Notes: \n"
		"After unlocking a request it is no longer guaranteed that the memory once referenced by the\n"
		"request and the image buffer belonging to it stays valid, so do **NEVER** try to access\n"
		"memory belonging to an unlocked request object. If you need to copy the image buffer or\n"
		"modify it in any other way, do everything you have to do **BEFORE** calling this function!\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::FunctionInterface::imageRequestReset**,\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::configure**\n"
		"\n"
		"Since: 1.12.68\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "Request_attachUserBuffer", _wrap_Request_attachUserBuffer, METH_VARARGS, "\n"
		" Convenience function to attach a user supplied buffer to a **mvIMPACT::acquire::Request** object.\n"
		" This function just provides a nicer way to attach a user supplied buffer to a **mvIMPACT::acquire::Request**.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" It e.g. makes it possible to write code like this:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,\n"
		"     const Request* pRequest = fi.getRequest( 0 ); // get access to request 0\n"
		"     pRequest-attachUserBuffer( getBufferFromSomewhere(), getBufferSizeFromSomewhere() );\n"
		"\n"
		" Instead if this:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,\n"
		"     const Request* pRequest = fi.getRequest( 0 ); // get access to request 0\n"
		"     if( pRequest-configure() == DMR_NO_ERROR )\n"
		"     {\n"
		"       pRequest-imageMemoryMode.write( rimmUser );\n"
		"       pRequest-imageData.write( getBufferFromSomewhere() );\n"
		"       pRequest-imageSize.write( getBufferSizeFromSomewhere() );\n"
		"       pRequest-unlock();\n"
		"     }\n"
		" }\n"
		"\n"
		" To find out more about capturing to user supplied buffers please\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" refer to the example 'CaptureToUserMemory.cpp' and\n"
		" }\n"
		" have a look at the documentation of the function **mvIMPACT::acquire::Request::configure**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Request::detachUserBuffer**,\n"
		"\n"
		"    mvIMPACT::acquire::FunctionInterface::imageRequestUnlock,\n"
		"\n"
		"    mvIMPACT::acquire::Request::unlock,\n"
		"\n"
		"    mvIMPACT::acquire::FunctionInterface::imageRequestConfigure,\n"
		"\n"
		"    mvIMPACT::acquire::Request::configure\n"
		"\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pBuf: void\n"
		":param pBuf: [in] A pointer to a user supplied buffer\n"
		":type bufSize: int\n"
		":param bufSize: [in] The size of the user supplied buffer\n"
		""},
	 { "Request_detachUserBuffer", _wrap_Request_detachUserBuffer, METH_O, "\n"
		" Convenience function to detach a user supplied buffer from a **mvIMPACT::acquire::Request** object.\n"
		" This function just provides a nicer way to detach a user supplied buffer from a **mvIMPACT::acquire::Request**.\n"
		" It e.g. allows to write code like this:\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface\n"
		"     const Request* pRequest = fi.getRequest( 0 ); // get access to request 0\n"
		"     pRequest-detachUserBuffer();\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT.acquire.FunctionInterface\n"
		"     Request pRequest = fi.getRequest( 0 ); // get access to request 0\n"
		"     pRequest.detachUserBuffer();\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     # 'fi' is assumed to be a valid instance of acquire.FunctionInterface\n"
		"     pRequest = fi.getRequest(0) # get access to request 0\n"
		"     pRequest.detachUserBuffer()\n"
		"}\n"
		"\n"
		" Instead if this:\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface\n"
		"     const Request* pRequest = fi.getRequest( 0 ); // get access to request 0\n"
		"     if( pRequest-configure() == DMR_NO_ERROR )\n"
		"     {\n"
		"       pRequest-imageMemoryMode.write( rimmAuto );\n"
		"       pRequest-unlock();\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // 'fi' is assumed to be a valid instance of mvIMPACT.acquire.FunctionInterface\n"
		"     Request pRequest = fi.getRequest( 0 ); // get access to request 0\n"
		"     if( pRequest.configure() == TDMR_ERROR.DMR_NO_ERROR )\n"
		"     {\n"
		"       pRequest.getImageMemoryMode().write( TRequestImageMemoryMode.rimmAuto );\n"
		"       pRequest.unlock();\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     # 'fi' is assumed to be a valid instance of acquire.FunctionInterface\n"
		"     pRequest = fi.getRequest(0) # get access to request 0\n"
		"     if pRequest.configure() == acquire.DMR_NO_ERROR:\n"
		"       pRequest.imageMemoryMode.write(acquire.rimmAuto)\n"
		"       pRequest.unlock()\n"
		"}\n"
		"\n"
		" To find out more about capturing to user supplied buffers please\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" refer to the example 'CaptureToUserMemory.cpp' and\n"
		" }\n"
		" have a look at the documentation of the function **mvIMPACT::acquire::Request::configure**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Request::attachUserBuffer**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::configure**\n"
		"\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "Request_requestResult_get", _wrap_Request_requestResult_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** defining the result of this request.\n"
		"This parameter indicates whether a previous image acquisition has been\n"
		"successful or not.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRequestResult**.\n"
		""},
	 { "Request_requestState_get", _wrap_Request_requestState_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** defining the current state of this request.\n"
		"This parameter indicates the current state of this request. A **mvIMPACT::acquire::Request** e.g.\n"
		"can currently be idle. This would mean that it is currently not used for\n"
		"image acquisition. Also a **mvIMPACT::acquire::Request** can be in 'Capturing' state, which means\n"
		"it is currently processed by the driver.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRequestState**.\n"
		""},
	 { "Request_infoFrameID_get", _wrap_Request_infoFrameID_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing a frame identifier.\n"
		"This parameter is returned as part of the **mvIMPACT::acquire::Request**. It is\n"
		"used to associate a certain image with a unique identifier.\n"
		"\n"
		"When an **mvIMPACT::acquire::RTCtrProgramStep** instruction of the type **mvIMPACT::acquire::rtctrlProgTriggerSet**\n"
		"is executed, the *frameID* is set to the value of the property *FrameID* of a corresponding **mvIMPACT::acquire::RTCtrProgramStep** if the\n"
		"HRTC is used and any program step executes the setting of the ID.\n"
		"\n"
		"If a device (e.g. a digital camera) supports the transmission of a unique identifier for an image, this property will reflect\n"
		"the identifier as transmitted by the device.\n"
		"\n"
		"Notes: **mvBlueFOX** and **mvHYPERION** specific:\n"
		"This property will only contain meaningful data if the device supports at least one **HRTC** and a program is running and writing data to\n"
		"the property OR if a device supports the transmission of a unique identifier for an image. Currently HRTC programs are supported by **mvBlueFOX** and **mvHYPERION** devices.\n"
		"\n"
		"**GigE** **Vision** and **USB3** **Vision** specific:\n"
		"This is the property where the so called block ID will be stored which is a unique identifier for each frame that will be transferred by the device as part of each frame as defined by the standard.\n"
		"- For **GigE** **Vision** 1.x compliant devices, this will be a 16 bit counter that will be incremented with every data block(e.g. an image or chunk data) transmitted\n"
		"by the device where '0' is a reserved value, which will never be used, thus values like this will be transmitted in a round robin scheme:\n"
		"1, 2, 3, ..., 65535, 1, 2, ...\n"
		"- For devices complying with version 2.0 and greater of the **GigE** **Vision** specification, this will be a 64 bit counter that will be incremented with every data block(e.g. an image or chunk data) transmitted\n"
		"by the device where '0' is a reserved value, which will never be used, thus values like this will be transmitted in a round robin scheme:\n"
		"1, 2, 3, ..., ((2^64)-1), 1, 2, ...\n"
		"- For **USB3** **Vision** compliant devices, this will be a 64 bit counter that will be incremented with every data block(e.g. an image or chunk data) transmitted\n"
		"by the device, thus values like this will be transmitted in a round robin scheme:\n"
		"0, 1, 2, ..., ((2^64)-1), 0, 1, ...\n"
		"\n"
		"Please note that due to the nature of **mvIMPACT::acquire::amContinuous** there might be gaps between the\n"
		"last image of a continuous stream and the first image of the next continuous stream if the device is stopped or re-programmed in between.\n"
		""},
	 { "Request_infoFrameNr_get", _wrap_Request_infoFrameNr_get, METH_O, "\n"
		"A 64 bit integer property **(read-only**, zero-based) containing the number of image requests processed since this driver instance has been opened.\n"
		"This counter is incremented regardless of the result this request is returned with thus also e.g. if a request did time out, was aborted(e.g. due to a call to **mvIMPACT::acquire::FunctionInterface::imageRequestReset** or **mvIMPACT::acquire::FunctionInterface::acquisitionStop)** or the data was not completely captured.\n"
		"So if a **mvIMPACT::acquire::Request** object contains the value *6* here, 6 requests have been processed before this one(the first request would contain the value *0)*\n"
		"This value is reset to 0 only if the current driver instance is closed.\n"
		""},
	 { "Request_infoExposeStart_us_get", _wrap_Request_infoExposeStart_us_get, METH_O, "\n"
		"An integer property **(read-only)** containing a timestamp (in us) defining the time the device started the exposure of the image associated with this **mvIMPACT::acquire::Request** object.\n"
		"This value will stay 0 if nothing is known about the time the exposure did start.\n"
		"In such a case the **mvIMPACT::acquire::Request::infoTimeStamp_us** property should be used instead.\n"
		""},
	 { "Request_infoExposeTime_us_get", _wrap_Request_infoExposeTime_us_get, METH_O, "\n"
		" An integer property **(read-only)** containing the 'real' expose time (in us) used to generate this image.\n"
		" This might differ slightly from the value selected by the user via\n"
		" the corresponding exposure property depending on the precision\n"
		" available for the device or the connected camera.\n"
		"\n"
		"Notes: When working with the **mvIMPACT::acquire::dilGenICam** this value will reflect the last value of the corresponding device\n"
		"property when it was written thus is a cached copy of the value that has been set by the application. For various operation modes\n"
		"this might **NOT** be the value actually used by the device for taking the image described by this request object. For example when\n"
		"AEC (exposureAuto) is active or the device is operated in a special sequencer mode the value of this property might be incorrect. When\n"
		"precise information about this value is needed it is recommended to work in chunk mode and use the exposure provided as chunk information instead.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::Device::interfaceLayout**,\n"
		"\n"
		"**mvIMPACT::acquire::GenICam::ChunkDataControl**,\n"
		"\n"
		"**mvIMPACT::acquire::GenICam::AcquisitionControl::exposureAuto**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::getChunkExposureTime**\n"
		""},
	 { "Request_infoTransferDelay_us_get", _wrap_Request_infoTransferDelay_us_get, METH_O, "\n"
		"An integer property **(read-only)** containing the time the transaction of this image has been delayed (in us) because either the bus was blocked or the CPU was busy.\n"
		"Normally this value will be 0. A value larger than 0 indicates that the system\n"
		"can't manage the current load.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "Request_infoGain_dB_get", _wrap_Request_infoGain_dB_get, METH_O, "\n"
		" A float property **(read-only)** containing the gain(in dB) this image has been taken with.\n"
		"Notes: When working with the **mvIMPACT::acquire::dilGenICam** this value will reflect the last value of the corresponding device\n"
		"property when it was written thus is a cached copy of the value that has been set by the application. For various operation modes\n"
		"this might **NOT** be the value actually used by the device for taking the image described by this request object. For example when\n"
		"AGC (gainAuto) is active or the device is operated in a special sequencer mode the value of this property might be incorrect. When\n"
		"precise information about this value is needed it is recommended to work in chunk mode and use the gain provided as chunk information instead.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::Device::interfaceLayout**,\n"
		"\n"
		"**mvIMPACT::acquire::GenICam::ChunkDataControl**,\n"
		"\n"
		"**mvIMPACT::acquire::GenICam::AnalogControl::gainAuto**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::getChunkGainCount**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::getChunkGain**\n"
		""},
	 { "Request_infoTimeStamp_us_get", _wrap_Request_infoTimeStamp_us_get, METH_O, "\n"
		" A 64 bit integer property **(read-only)** containing a timestamp to define the exact time this image has been captured (usually either at exposure start or exposure end, depending on the device).\n"
		"**mvBlueFOX** specific:\n"
		"The counter of the timestamp starts when the camera gets initialized. It is measured in us.\n"
		""},
	 { "Request_infoSettingUsed_get", _wrap_Request_infoSettingUsed_get, METH_O, "\n"
		"A enumerated integer property **(read-only)** containing the setting that was used for processing this request.\n"
		"The string representation will be a valid setting name, the integer representation can be casted into a **mvIMPACT::acquire::HOBJ** type.\n"
		""},
	 { "Request_infoImageAverage_get", _wrap_Request_infoImageAverage_get, METH_O, " Currently unsupported."},
	 { "Request_infoVideoChannel_get", _wrap_Request_infoVideoChannel_get, METH_O, "\n"
		"An integer property **(read-only)** containing the video input channel of the device this image has been acquired from.\n"
		"Notes: \n"
		"This property is not supported by every device and will only be available if the device has more than one input channel.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "Request_infoCameraOutputUsed_get", _wrap_Request_infoCameraOutputUsed_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** containing the camera output used to transmit the image to the capture device.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraOutput**.\n"
		"\n"
		"Notes: This property is not supported by every device. Therefore always call the function **mvIMPACT::acquire::Component::isValid**\n"
		"to check if this property is available or not.\n"
		""},
	 { "Request_infoLineCounter_get", _wrap_Request_infoLineCounter_get, METH_O, "\n"
		"An integer property **(read-only)** containing the number of lines since the last trigger event.\n"
		"Will contain\n"
		"- the number of lines since last trigger event of the first line of the snap if line counting is enabled\n"
		"- -1 otherwise\n"
		"\n"
		"Notes: This property is not supported by every device. Therefore always call the function **mvIMPACT::acquire::Component::isValid**\n"
		"to check if this property is available or not.\n"
		""},
	 { "Request_infoMissingData_pc_get", _wrap_Request_infoMissingData_pc_get, METH_O, "\n"
		"A float property **(read-only)** containing the amount of data missing in the current image.\n"
		"The value of this property will be 0 almost always. However if a device\n"
		"can detect blocks of missing data and an image request has returned with **mvIMPACT::acquire::rrFrameIncomplete**\n"
		"to indicate that not all the data has been captured, this property will contain the amount of data missing in percent.\n"
		""},
	 { "Request_infoIOStatesAtExposureStart_get", _wrap_Request_infoIOStatesAtExposureStart_get, METH_O, "\n"
		" An integer property **(read-only)** containing the state of all the IO lines at the beginning of the frame exposure as a device specific bit field.\n"
		" The following table documents which bit in this property represents the state of which digital I/O for **mvBlueFOX** devices:\n"
		"\n"
		"\n"
		" |bit|IO|\n"
		" |0|in 0|\n"
		" |1|in 1|\n"
		" |2|in 2(if available)|\n"
		" |3|in 3(if available)|\n"
		" |4|out 0|\n"
		" |5|out 1|\n"
		" |6|out 2(if available)|\n"
		" |7|out 3(if available)|\n"
		"\n"
		"\n"
		"This feature is currently only available for **mvBlueFOX-MLC** devices!\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     #include sstream\n"
		"     #include mvIMPACT/mvIMPACT_acquire.h\n"
		"\n"
		"     using namespace std;\n"
		"     using namespace mvIMPACT::acquire;\n"
		"\n"
		"     //-----------------------------------------------------------------------------\n"
		"     templatetypename _Ty\n"
		"     string decToBinString( _Ty value )\n"
		"     //-----------------------------------------------------------------------------\n"
		"     {\n"
		"       const size_t bitCount = sizeof(_Ty)*8;\n"
		"       ostringstream oss;\n"
		"       for( size_t i=0; ibitCount; i++ )\n"
		"       {\n"
		"         oss < ( ( value  ( 1 < ( bitCount - 1 - i ) ) ) ? \"1\" : \"0\" );\n"
		"       }\n"
		"       return oss.str();\n"
		"     }\n"
		"\n"
		"     //-----------------------------------------------------------------------------\n"
		"     void printIOStateOfAValidRequest( const Request* pRequest )\n"
		"     //-----------------------------------------------------------------------------\n"
		"     {\n"
		"       if( pRequest-infoIOStatesAtExposureStart.isValid() )\n"
		"       {\n"
		"          cout < pRequest-infoIOStatesAtExposureStart.name() < \": \" < decToBinString( pRequest-infoIOStatesAtExposureStart.read() ) < endl;\n"
		"       }\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     //-----------------------------------------------------------------------------\n"
		"     public static void printIOStateOfAValidRequest( Request pRequest )\n"
		"     //-----------------------------------------------------------------------------\n"
		"     {\n"
		"       if( pRequest.getInfoIOStatesAtExposureStart().isValid() )\n"
		"       {\n"
		"          System.out.println( pRequest.getInfoIOStatesAtExposureStart().name() + \": \" + Integer.toBinaryString( pRequest.getInfoIOStatesAtExposureStart().read() ) );\n"
		"       }\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     def printIOStateOfAValidRequest(pRequest):\n"
		"       if pRequest.infoIOStatesAtExposureStart.isValid:\n"
		"         print(pRequest.infoIOStatesAtExposureStart.name() + \": \" + format(pRequest.infoIOStatesAtExposureStart.read(), '32b'))\n"
		"}\n"
		" Notes: This property is not supported by every device. Therefore always call the function **mvIMPACT::acquire::Component::isValid**\n"
		" to check if this property is available or not.\n"
		""},
	 { "Request_infoIOStatesAtExposureEnd_get", _wrap_Request_infoIOStatesAtExposureEnd_get, METH_O, "\n"
		"An integer property **(read-only)** containing the state of all the IO lines at the end of the frame exposure as a device specific bit field.\n"
		"See **mvIMPACT::acquire::Request::infoIOStatesAtExposureStart** for details on how to interpret the data.\n"
		"\n"
		"Notes: This property is not supported by every device. Therefore always call the function **mvIMPACT::acquire::Component::isValid**\n"
		"to check if this property is available or not.\n"
		""},
	 { "Request_chunkOffsetX_get", _wrap_Request_chunkOffsetX_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the X-offset of the image in pixels as returned in the chunk data attached to the image.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		""},
	 { "Request_chunkOffsetY_get", _wrap_Request_chunkOffsetY_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the Y-offset of the image in pixels as returned in the chunk data attached to the image.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		""},
	 { "Request_chunkWidth_get", _wrap_Request_chunkWidth_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the width of the image in pixels as returned in the chunk data attached to the image.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		""},
	 { "Request_chunkHeight_get", _wrap_Request_chunkHeight_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the height of the image in pixels as returned in the chunk data attached to the image.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		""},
	 { "Request_chunkPixelFormat_get", _wrap_Request_chunkPixelFormat_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the pixel format of the image as returned in the chunk data attached to the image.\n"
		"This will **NOT** be a valid mvIMPACT Acquire pixel format but e.g. a GigE Vision, USB3 Vision of PFNC compliant pixel format or something else.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		""},
	 { "Request_chunkDynamicRangeMin_get", _wrap_Request_chunkDynamicRangeMin_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the minimum value of dynamic range of the image as returned in the chunk data attached to the image.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		""},
	 { "Request_chunkDynamicRangeMax_get", _wrap_Request_chunkDynamicRangeMax_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the maximum value of dynamic range of the image as returned in the chunk data attached to the image.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		""},
	 { "Request_chunkExposureTime_get", _wrap_Request_chunkExposureTime_get, METH_O, "\n"
		" A floating point property **(read-only)** containing the exposure time used to capture the image as returned in the chunk data attached to the image.\n"
		" Notes: \n"
		" For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		"Since: 2.5.16\n"
		""},
	 { "Request_chunkTimestamp_get", _wrap_Request_chunkTimestamp_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the timestamp value of the internal frame start signal of the image as returned in the chunk data attached to the image.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		""},
	 { "Request_chunkLineStatusAll_get", _wrap_Request_chunkLineStatusAll_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the status of all I/O lines at the time of the internal frame start signal of the image as returned in the chunk data attached to the image.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		""},
	 { "Request_chunkSequencerSetActive_get", _wrap_Request_chunkSequencerSetActive_get, METH_O, "\n"
		"A 64-bit integer property **(read-only)** containing the index of the active set of the running sequencer use during the creation of this block of data.\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		"Since: 2.12.3\n"
		""},
	 { "Request_chunkmvCustomIdentifier_get", _wrap_Request_chunkmvCustomIdentifier_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the previously configured user defined identifier attached to the image.\n"
		"This identifier can be specified by some other functions belonging to this SDK. If not specified this value will be 0.\n"
		"\n"
		"Notes: \n"
		"For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.\n"
		"\n"
		"Since: 2.17.3\n"
		""},
	 { "Request_imageMemoryMode_get", _wrap_Request_imageMemoryMode_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** containing the memory mode used for this request.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRequestImageMemoryMode**.\n"
		"\n"
		"Notes: This property will become writeable if this request is in configuration mode.\n"
		"See also: \n"
		"**mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::configure**\n"
		""},
	 { "Request_imagePixelFormat_get", _wrap_Request_imagePixelFormat_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** containing the pixel format of this image.\n"
		"This might be important, when the image data needs to be processed or stored in\n"
		"a file or maybe even if the image shall be displayed.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageBufferPixelFormat**.\n"
		""},
	 { "Request_imageData_get", _wrap_Request_imageData_get, METH_O, "\n"
		" A pointer property **(read-only)** containing the start address of the image data.\n"
		" This address in connection with **mvIMPACT::acquire::Request::imageSize** is sufficient\n"
		" to copy the complete image without having any additional information about it.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     FunctionInterface fi = getFunctionInterfaceFromSomewhere();\n"
		"     int currentRequestNr = getCurrentRequestNumberFromSomewhere();\n"
		"     const Request* pRequest = fi.getRequest( currentRequestNr );\n"
		"     char* pTempBuf = new char[pRequest-imageSize.read()];\n"
		"     memcpy( pTempBuf, pRequest-imageData.read(), pRequest-imageSize.read() );\n"
		"     // free the memory once no longer needed...\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		" FunctionInterface fi = getFunctionInterfaceFromSomewhere();\n"
		" int currentRequestNr = getCurrentRequestNumberFromSomewhere();\n"
		" Request pRequest = fi.getRequest( currentRequestNr );\n"
		" byte[] data = new byte[pRequest.getImageSize().read()];\n"
		" pRequest.getImageBufferDesc().copy( data );\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     currentRequestNr = getCurrentRequestNumberFromSomewhere()\n"
		"     pRequest = fi.getRequest(currentRequestNr)\n"
		"     cbuf = (ctypes.c_char * pRequest.imageSize.read()).from_address(int(pRequest.imageData.read()))\n"
		"}\n"
		"\n"
		" Notes: \n"
		" It's not always necessary to copy the image data! Each image buffer is an\n"
		" integral part of the **mvIMPACT::acquire::Request** object returned to the user by a call to\n"
		" the corresponding 'waitFor' function offered by the interface.\n"
		" The data in this buffer remains valid until the user either\n"
		" unlocks the request buffer or closes the **mvIMPACT::acquire::Device** again.\n"
		"\n"
		"\n"
		" By unlocking the **mvIMPACT::acquire::Request**, the user informs the driver that this **mvIMPACT::acquire::Request**\n"
		" and the image buffer belonging to that **mvIMPACT::acquire::Request** is no longer needed by the\n"
		" user. The driver then queues this **mvIMPACT::acquire::Request** for capturing image data into it once\n"
		" again. However, once a **mvIMPACT::acquire::Request** has been returned to the user, its image buffer\n"
		" can't be overwritten by the driver! Therefore the user can work with, modify, store or\n"
		" copy the data safely until he unlocks the **mvIMPACT::acquire::Request** again.\n"
		"\n"
		" This property will become writeable if this request is in configuration mode.\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::configure**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::imageSize**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::imageFooterSize**\n"
		""},
	 { "Request_imageSize_get", _wrap_Request_imageSize_get, METH_O, "\n"
		"An integer property **(read-only)** containing the size (in bytes) of the whole image.\n"
		"This value in connection with **mvIMPACT::acquire::Request::imageData** is sufficient\n"
		"to copy the complete image without having any additional information about it.\n"
		"\n"
		"Notes: This property will become writeable if this request is in configuration mode.\n"
		"See also: \n"
		"**mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::configure**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::imageData**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::imageFooterSize**\n"
		""},
	 { "Request_imageFooter_get", _wrap_Request_imageFooter_get, METH_O, "\n"
		"A pointer property **(read-only)** containing the start address of the footer associated with this image.\n"
		"A footer may contain additional data like e.g. information about the image (e.g. the exposure time used for this image).\n"
		"If this property contains the value '0' no footer is attached to this image.\n"
		"\n"
		"Notes: \n"
		"In general it is not necessary to access footer data. Sometime e.g. when the hardware already does some image pre-processing\n"
		"a footer containing additional information about the image data might be attached to the image. In this case some additional\n"
		"information about the structure of the footer might be needed as well.\n"
		""},
	 { "Request_imageFooterSize_get", _wrap_Request_imageFooterSize_get, METH_O, " An integer property **(read-only)** containing the size (in bytes) of the footer associated with this image. If this property contains the value '0' no footer is attached to this image."},
	 { "Request_imagePixelPitch_get", _wrap_Request_imagePixelPitch_get, METH_O, "\n"
		"An integer property **(read-only)** containing the offset (in bytes) to the next pixel of the specified channel of this image.\n"
		"Notes: \n"
		"This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function\n"
		"**mvIMPACT::acquire::PropertyI::read()** or in a single call by using the overloaded *read* function accepting a reference to a\n"
		"vector.\n"
		""},
	 { "Request_imageChannelCount_get", _wrap_Request_imageChannelCount_get, METH_O, "\n"
		"An integer property **(read-only)** containing the number of channels this image consists of.\n"
		"For an RGB image this value e.g. would be 3. This value also defines how many parameters are stored by the properties\n"
		"**mvIMPACT::acquire::Request::imagePixelPitch**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::imageLinePitch**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::imageChannelBitDepth**,\n"
		"\n"
		"**mvIMPACT::acquire::Request::imageChannelDesc** and\n"
		"\n"
		"**mvIMPACT::acquire::Request::imageChannelOffset**.\n"
		"\n"
		"If e.g. the channel count is 3 a call like pRequest->imageChannelOffset.read( 2 ) would return the channel offset of\n"
		"channel 3 (as calls to the read functions of properties are '0' based).\n"
		""},
	 { "Request_imageChannelOffset_get", _wrap_Request_imageChannelOffset_get, METH_O, "\n"
		" An integer property **(read-only)** containing the offset (in bytes) to each channel belonging to the current image relative to the address contained in **mvIMPACT::acquire::Request::imageData**.\n"
		"Notes: \n"
		"This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function\n"
		"**mvIMPACT::acquire::PropertyI::read()** or in a single call by using the overloaded *read* function accepting a reference to a\n"
		"vector.\n"
		""},
	 { "Request_imageChannelBitDepth_get", _wrap_Request_imageChannelBitDepth_get, METH_O, "\n"
		"An integer property **(read-only)** containing the number of effective bits stored in each channel belonging to the current image.\n"
		"Notes: \n"
		"This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function\n"
		"**mvIMPACT::acquire::PropertyI::read()** or in a single call by using the overloaded *read* function accepting a reference to a\n"
		"vector.\n"
		""},
	 { "Request_imageLinePitch_get", _wrap_Request_imageLinePitch_get, METH_O, "\n"
		"An integer property **(read-only)** containing the offset (in bytes) to the next line of each channel belonging to the current image.\n"
		"Notes: \n"
		"This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function\n"
		"**mvIMPACT::acquire::PropertyI::read()** or in a single call by using the overloaded *read* function accepting a reference to a\n"
		"vector.\n"
		""},
	 { "Request_imageChannelDesc_get", _wrap_Request_imageChannelDesc_get, METH_O, "\n"
		" A string property **(read-only)** containing the string descriptors of each channel belonging to the current image.\n"
		"Notes: \n"
		" This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function\n"
		" **mvIMPACT::acquire::PropertyS::read()** or in a single call by using the overloaded *read* function accepting a reference to a\n"
		" vector.\n"
		"\n"
		" For an RGB image this property e.g. might contain three values \"R\", \"G\" and \"B\".\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     FunctionInterface fi = getFunctionInterfaceFromSomewhere();\n"
		"     int currentRequestNr = getCurrentRequestNumberFromSomewhere();\n"
		"     const Request* pRequest = fi.getRequest( currentRequestNr );\n"
		"     int channelCount = pRequest-imageChannelCount.read();\n"
		"     for( int i=0; ichannelCount; i++ )\n"
		"     {\n"
		"       cout < \"channel[\" < i < \"]: \" < pRequest-imageChannelDesc.read( i ) < endl;\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     FunctionInterface fi = getFunctionInterfaceFromSomewhere();\n"
		"     int currentRequestNr = getCurrentRequestNumberFromSomewhere();\n"
		"     Request pRequest = fi.getRequest( currentRequestNr );\n"
		"     int channelCount = pRequest.getImageChannelCount().read();\n"
		"     for( int i=0; ichannelCount; i++ )\n"
		"     {\n"
		"       System.out.println( String.format( \"channel[%d]: %s\", i, pRequest.getImageChannelDesc().read( i ) ) );\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     fi = getFunctionInterfaceFromSomewhere()\n"
		"     currentRequestNr = getCurrentRequestNumberFromSomewhere()\n"
		"     pRequest = fi.getRequest(currentRequestNr)\n"
		"     channelCount = pRequest.imageChannelCount.read()\n"
		"     for i in range(channelCount):\n"
		"       print(\"channel[\", i, \"]: \", pRequest.imageChannelDesc.read(i))\n"
		"}\n"
		""},
	 { "Request_imageBytesPerPixel_get", _wrap_Request_imageBytesPerPixel_get, METH_O, " An integer property **(read-only)** containing the number of bytes per pixel in this image."},
	 { "Request_imageOffsetX_get", _wrap_Request_imageOffsetX_get, METH_O, "\n"
		"An integer property **(read-only)** containing the X-offset of the image in pixels.\n"
		"Notes: \n"
		"This feature will be supported by devices using an mvIMPACT Acquire driver greater or equal version 1.10.92.\n"
		""},
	 { "Request_imageOffsetY_get", _wrap_Request_imageOffsetY_get, METH_O, "\n"
		"An integer property **(read-only)** containing the Y-offset of the image in pixels.\n"
		"Notes: \n"
		"This feature will be supported by devices using an mvIMPACT Acquire driver greater or equal version 1.10.92.\n"
		""},
	 { "Request_imageWidth_get", _wrap_Request_imageWidth_get, METH_O, " An integer property **(read-only)** containing the width of the image in pixels."},
	 { "Request_imageWidthTotal_get", _wrap_Request_imageWidthTotal_get, METH_O, "\n"
		"An integer property **(read-only)** containing the total width of the image in pixels if this buffer is part of a larger image.\n"
		"Notes: \n"
		"This feature will be supported by devices using an mvIMPACT Acquire driver greater or equal version 1.11.50. Not\n"
		"every device driver will be capable of dealing with multiple buffers forming a single image. If a device driver can\n"
		"not deliver parts of a larger image, then this property will always contain the same value as returned by\n"
		"**mvIMPACT::acquire::Request::imageWidth**.\n"
		""},
	 { "Request_imageHeight_get", _wrap_Request_imageHeight_get, METH_O, " An integer property **(read-only)** containing the height of the image in pixels."},
	 { "Request_imageHeightTotal_get", _wrap_Request_imageHeightTotal_get, METH_O, "\n"
		"An integer property **(read-only)** containing the total height of the image in pixels if this buffer is part of a larger image.\n"
		"Notes: \n"
		"This feature will be supported by devices using an mvIMPACT Acquire driver greater or equal version 1.11.50. Not\n"
		"every device driver will be capable of dealing with multiple buffers forming a single image. If a device driver can\n"
		"not deliver parts of a larger image, then this property will always contain the same value as returned by\n"
		"**mvIMPACT::acquire::Request::imageHeight**.\n"
		""},
	 { "Request_imageBayerMosaicParity_get", _wrap_Request_imageBayerMosaicParity_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** containing the Bayer parity of this image.\n"
		"If the current image does not contain Bayer data, this value will be **mvIMPACT::acquire::bmpUndefined**.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.\n"
		""},
	 { "disown_Request", _wrap_disown_Request, METH_O, NULL},
	 { "Request_swigregister", Request_swigregister, METH_O, NULL},
	 { "Request_swiginit", Request_swiginit, METH_VARARGS, NULL},
	 { "new_ImageRequestControl", _wrap_new_ImageRequestControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::ImageRequestControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type name: string\n"
		":param name: [in] The name of the driver internal image request control to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableImageRequestControls**, new image request controls can be created with the function **mvIMPACT::acquire::FunctionInterface::createImageRequestControl**\n"
		""},
	 { "ImageRequestControl_mode_get", _wrap_ImageRequestControl_mode_get, METH_O, "\n"
		" The mode this object shall be operated in.\n"
		" Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageRequestControlMode**.\n"
		"\n"
		" This property can e.g. be used to prepare internal data structures without requesting a\n"
		" 'real' image from the hardware. This can be useful when the image dimensions must be known\n"
		" before the first image is captured.\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     Device* pDev = getDevicePointerFromSomewhere();\n"
		"     ImageRequestControl irc( pDev );\n"
		"     irc.mode.write( ircmTrial ); // set to prepare mode\n"
		"     FunctionInterface fi( pDev );\n"
		"     fi.imageRequestSingle( irc ); // request dummy image\n"
		"     int reqNr = fi.imageRequestWaitFor( 500 );\n"
		"     // waitFor will return as fast as possible. No 'real' image will be taken\n"
		"     // but a request object that contains a dummy image with the format, dimensions\n"
		"     // and other information will be returned that is (apart from the pixel data)\n"
		"     // similar to any 'real' image that would be captured with the current settings\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     Device pDev = getDevicePointerFromSomewhere();\n"
		"     ImageRequestControl irc = new ImageRequestControl( pDev );\n"
		"     irc.getMode().write( TImageRequestControlMode.ircmTrial ); // set to prepare mode\n"
		"     FunctionInterface fi = new FunctionInterface( pDev );\n"
		"     fi.imageRequestSingle( irc ); // request dummy image\n"
		"     int reqNr = fi.imageRequestWaitFor( 500 );\n"
		"     // waitFor will return as fast as possible. No 'real' image will be taken\n"
		"     // but a request object that contains a dummy image with the format, dimensions\n"
		"     // and other information will be returned that is (apart from the pixel data)\n"
		"     // similar to any 'real' image that would be captured with the current settings\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     pDev = getDeviceFromSomewhere()\n"
		"     irc = ImageRequestControl(pDev)\n"
		"     irc.mode.write(acquire.ircmTrial) # set to prepare mode\n"
		"     fi = FunctionInterface(pDev)\n"
		"     fi.imageRequestSingle(irc) # request dummy image\n"
		"     reqNr = fi.imageRequestWaitFor(500)\n"
		"     # waitFor will return as fast as possible. No 'real' image will be taken\n"
		"     # but a request object that contains a dummy image with the format, dimensions\n"
		"     # and other information will be returned that is (apart from the pixel data)\n"
		"     # similar to any 'real' image that would be captured with the current settings\n"
		"}\n"
		""},
	 { "ImageRequestControl_imageCount_get", _wrap_ImageRequestControl_imageCount_get, METH_O, "\n"
		"An integer property defining the number of images to capture with each request.\n"
		"Notes: This property will currently have no effect.\n"
		""},
	 { "ImageRequestControl_setting_get", _wrap_ImageRequestControl_setting_get, METH_O, "\n"
		"An integer property defining which setting will be used for the acquisition.\n"
		"This property defines a translation dictionary. It maps the name of the setting (the parameter\n"
		"passed to the function **mvIMPACT::acquire::FunctionInterface::createSetting)** to the actual\n"
		"underlying handle of the request. Therefore either the name or the handle of the setting can be used\n"
		"to set this property to the desired value.\n"
		""},
	 { "ImageRequestControl_requestQueue_get", _wrap_ImageRequestControl_requestQueue_get, METH_O, "\n"
		" An integer property defining to which request queue the image request will be sent.\n"
		"This property defines the stream channel requests associated with this request control instance will be sent to.\n"
		"\n"
		"The maximum value for this feature corresponds to the number of independent stream channels offered by the device. Only devices operated in\n"
		"interface layout **mvIMPACT::acquire::dilGenICam** may offer more than one stream channel. Therefore the default\n"
		"value and the default maximum and minimum value will be 0 for most devices.\n"
		"\n"
		"Since: 2.47.0\n"
		""},
	 { "ImageRequestControl_resultQueue_get", _wrap_ImageRequestControl_resultQueue_get, METH_O, " An integer property defining to which result queue the resulting image will be sent after the acquisition."},
	 { "ImageRequestControl_requestToUse_get", _wrap_ImageRequestControl_requestToUse_get, METH_O, "\n"
		"An integer property defining which request object shall be used for the next image request.\n"
		"This is an advanced feature that should only be used if needed. A value smaller than 0 will\n"
		"result in an automatic mode. This is the default behaviour and the driver will decide which buffer to use next then.\n"
		"\n"
		"A request can only be sent to the driver once. Until this request is returned to the user it can't\n"
		"be sent again thus this property must be changed for each request if multiple requests shall be sent to\n"
		"the capture queue.\n"
		""},
	 { "delete_ImageRequestControl", _wrap_delete_ImageRequestControl, METH_O, NULL},
	 { "ImageRequestControl_swigregister", ImageRequestControl_swigregister, METH_O, NULL},
	 { "ImageRequestControl_swiginit", ImageRequestControl_swiginit, METH_VARARGS, NULL},
	 { "delete_RequestFactory", _wrap_delete_RequestFactory, METH_O, NULL},
	 { "RequestFactory_createRequest", _wrap_RequestFactory_createRequest, METH_VARARGS, NULL},
	 { "new_RequestFactory", _wrap_new_RequestFactory, METH_O, NULL},
	 { "disown_RequestFactory", _wrap_disown_RequestFactory, METH_O, NULL},
	 { "RequestFactory_swigregister", RequestFactory_swigregister, METH_O, NULL},
	 { "RequestFactory_swiginit", RequestFactory_swiginit, METH_VARARGS, NULL},
	 { "new_FunctionInterface", _wrap_new_FunctionInterface, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new function interface for the device pointed to by *pDev*.\n"
		" In order to work with the **mvIMPACT::acquire::FunctionInterface** object the device needs to be\n"
		" initialized, so if the **mvIMPACT::acquire::Device** object pointed to by *pDev* in the constructors\n"
		" parameter list hasn't been opened already the constructor will try to do that.\n"
		" Thus internally a call to **mvIMPACT::acquire::Device::open** might be preformed with all consequences\n"
		" following from this call.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Device::open**\n"
		"\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type pRequestFactory: :py:class:`RequestFactory`\n"
		":param pRequestFactory: [in] A pointer to a request factory. By supplying a custom request factory the user can control the type of request objects that will be created by the function interface. Since: 1.12.56\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::FunctionInterface** from an existing one.\n"
		":type src: :py:class:`FunctionInterface`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::FunctionInterface** object, this object shall be created from\n"
		""},
	 { "delete_FunctionInterface", _wrap_delete_FunctionInterface, METH_O, " Class destructor."},
	 { "FunctionInterface_acquisitionStart", _wrap_FunctionInterface_acquisitionStart, METH_O, "\n"
		" Manually starts the acquisition engine of this device driver instance.\n"
		" Calling this function will manually start this device driver's acquisition engine. This will only\n"
		" have an effect on the overall behaviour if **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is\n"
		" set to **mvIMPACT::acquire::assbUser**.\n"
		"\n"
		" If supported by the device driver, starting and stopping the acquisition engine manually can sometimes\n"
		" help to overcome capture queue underruns or certain restrictions in the underlying device driver\n"
		" technology.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStop**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::configure**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**\n"
		"\n"
		"Since: 1.12.11\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE** if this device/driver combination does not support manual control over the acquisition engine. This will also happen if **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is **NOT** set to **mvIMPACT::acquire::assbUser**.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "FunctionInterface_acquisitionStop", _wrap_FunctionInterface_acquisitionStop, METH_O, "\n"
		" Manually stops the acquisition engine of this device driver instance.\n"
		" Calling this function will manually stop this device drivers acquisition engine. This will only\n"
		" have effect on the overall behaviour, if **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is\n"
		" set to **mvIMPACT::acquire::assbUser**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStart**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::configure**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**\n"
		"\n"
		"Since: 1.12.11\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE** if this device/driver combination does not support manual control over the acquisition engine. This will also happen if **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is **NOT** set to **mvIMPACT::acquire::assbUser**.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "FunctionInterface_createImageRequestControl", _wrap_FunctionInterface_createImageRequestControl, METH_VARARGS, "\n"
		" Creates a new **mvIMPACT::acquire::ImageRequestControl** object.\n"
		" This function creates a new **mvIMPACT::acquire::ImageRequestControl** based on an existing one. New **mvIMPACT::acquire::ImageRequestControl** instances can only be derived\n"
		" from **mvIMPACT::acquire::ImageRequestControl** instances that already exist. When the driver has been initialized there will be at least\n"
		" one base **mvIMPACT::acquire::ImageRequestControl** called 'Base', which acts as the base for all other request controls.\n"
		"\n"
		" All **mvIMPACT::acquire::ImageRequestControl** constructed by the application must be derived either from this base or any of its children using this function.\n"
		"\n"
		" When this function succeeds, the **mvIMPACT::acquire::ImageRequestControl** constructor can be called with the *name* parameter passed to this function\n"
		" to get access to this newly registered **mvIMPACT::acquire::ImageRequestControl**.\n"
		"\n"
		" Notes: \n"
		" See all comments made under **mvIMPACT::acquire::FunctionInterface::createSetting** for understanding the relationship between base and\n"
		" derived **mvIMPACT::acquire::ImageRequestControl** objects.\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name of the new **mvIMPACT::acquire::ImageRequestControl** object.\n"
		":type parent: string\n"
		":param parent: [in] The name of the **mvIMPACT::acquire::ImageRequestControl** the new object shall be derived from.\n"
		":type pNewRequestControl: :py:class:`ComponentList`\n"
		":param pNewRequestControl: [out] A pointer to a **mvIMPACT::acquire::ComponentList** object that will receive the ID of the newly created request control. This parameter can be 0 if the application is not interested in that parameter.\n"
		""},
	 { "FunctionInterface_createSetting", _wrap_FunctionInterface_createSetting, METH_VARARGS, "\n"
		" Creates a new setting.\n"
		" This function creates a new setting base on an existing one. New settings can only be derived\n"
		" from settings that already exist. When the driver has been initialized there will be at least\n"
		" one base setting called 'Base', which acts as the base for all other settings.\n"
		"\n"
		" When a new setting is created it derives all the properties from the parent setting. That means\n"
		" initially the new setting will contain the very same data as the parent setting. As long as a\n"
		" component hasn't been modified in the new setting it will depend on the parent settings data.\n"
		" That means if e.g. a property in the parent list is modified, the newly created setting will\n"
		" also benefit from the updated value.\n"
		"\n"
		" To release a certain component from this dependency it must be assigned a new value. The function\n"
		" **mvIMPACT::acquire::Component::isDefault** will return false afterwards indicating that the component no longer\n"
		" depends on the parent.\n"
		"\n"
		" To restore this parent <-> child dependency the user can call the function\n"
		" **mvIMPACT::acquire::Component::restoreDefault**. Afterwards settings applied to the parent component\n"
		" will also be visible in the child component again.\n"
		"\n"
		" When a new setting has been created successfully the name used to create the setting can\n"
		" be passed to any of the constructors of the setting related classes (**mvIMPACT::acquire::CameraSettingsBase**,\n"
		" **mvIMPACT::acquire::ImageProcessing**, ...) to access the new components.\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name of the setting to be created.\n"
		":type parent: string\n"
		":param parent: [in] The name of the setting to derive the new setting from.\n"
		":type pNewSetting: :py:class:`ComponentList`\n"
		":param pNewSetting: [out] A pointer to a **mvIMPACT::acquire::ComponentList** object that will receive the ID of the newly created setting. This parameter can be 0 if the application is not interested in that parameter.\n"
		""},
	 { "FunctionInterface_deleteSettingFromStack", _wrap_FunctionInterface_deleteSettingFromStack, METH_O, "\n"
		" Deletes the last setting from the setting stack.\n"
		" This function deletes the last setting from the setting stack.\n"
		"\n"
		" See **mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack** for an example how to use this feature.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack**\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::loadSettingFromStack**\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::loadAndDeleteSettingFromStack**\n"
		"\n"
		"\n"
		" Since: 2.19.0\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		""},
	 { "FunctionInterface_deleteSetting", _wrap_FunctionInterface_deleteSetting, METH_VARARGS, "\n"
		" Deletes a setting from the specified location.\n"
		" This function deletes a setting from the specified location.\n"
		"\n"
		" Since: 2.19.0\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name or the full path under where the setting is located.\n"
		":type storageLocation: int\n"
		":param storageLocation: [in] The location of the setting.\n"
		":type scope: int\n"
		":param scope: [in] Specifies the scope of this operation.\n"
		""},
	 { "FunctionInterface_getAvailableSettings", _wrap_FunctionInterface_getAvailableSettings, METH_O, "\n"
		"Returns the names of the settings available for this **mvIMPACT::acquire::Device**.\n"
		"This function returns a const reference to a string array containing the names of all settings available\n"
		"for the current **mvIMPACT::acquire::Device**. These names are valid constructor parameters for objects\n"
		"like **mvIMPACT::acquire::CameraSettingsBase**, **mvIMPACT::acquire::ImageProcessing**, **mvIMPACT::acquire::ImageDestination** or\n"
		"classes derived from these types.\n"
		"\n"
		"New settings can be created by calling\n"
		"**mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		":rtype: std::vector< std::string,std::allocator< std::string > >\n"
		":return: A const reference to an array containing the names of all request controls available.\n"
		""},
	 { "FunctionInterface_getAvailableImageRequestControls", _wrap_FunctionInterface_getAvailableImageRequestControls, METH_O, "\n"
		"Returns the names of the image request controls available for this **mvIMPACT::acquire::Device**.\n"
		"This function returns a const reference to a string array containing the names of all image request controls available\n"
		"for the current **mvIMPACT::acquire::Device**. These names are valid constructor parameters for objects\n"
		"of the type **mvIMPACT::acquire::ImageRequestControl**.\n"
		"\n"
		"New image request controls can be created by calling **mvIMPACT::acquire::FunctionInterface::createImageRequestControl**.\n"
		":rtype: std::vector< std::string,std::allocator< std::string > >\n"
		":return: A const reference to an array containing the names of all settings available.\n"
		""},
	 { "FunctionInterface_getRequest", _wrap_FunctionInterface_getRequest, METH_VARARGS, "\n"
		" Returns a pointer to the desired **mvIMPACT::acquire::Request**.\n"
		" This function returns a pointer to the **mvIMPACT::acquire::Request** stored at *nr*\n"
		" in the internal array of requests.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* refers to an invalid **mvIMPACT::acquire::Request**\n"
		"\n"
		" (e.g. when *nr* is higher than the actual number of\n"
		"\n"
		" available requests) an STL out_of_range exception will be thrown.\n"
		" }\n"
		" :rtype: :py:class:`Request`\n"
		" :return: A pointer to a **mvIMPACT::acquire::Request** object.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the request to return\n"
		""},
	 { "FunctionInterface_getSetting", _wrap_FunctionInterface_getSetting, METH_VARARGS, "\n"
		" Returns a **mvIMPACT::acquire::ComponentList** object to a setting with a specified name.\n"
		" This function returns a **mvIMPACT::acquire::ComponentList** object to a setting with a specified name\n"
		" or will raise an exception if no such setting exists.\n"
		"\n"
		" Since: 1.12.58\n"
		"\n"
		" :rtype: :py:class:`ComponentList`\n"
		" :return: A **mvIMPACT::acquire::ComponentList** object to a setting with a specified name\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name of the setting to locate\n"
		""},
	 { "FunctionInterface_imageRequestConfigure", _wrap_FunctionInterface_imageRequestConfigure, METH_VARARGS, "\n"
		" Sets a request into configuration mode.\n"
		" Notes: \n"
		" Another version of this function is available that might be nicer to use depending on personal\n"
		" preferences and use case: **mvIMPACT::acquire::Request::configure**.\n"
		"\n"
		" In configuration mode certain properties like **mvIMPACT::acquire::Request::imageData**,\n"
		" **mvIMPACT::acquire::Request::imageSize**, **mvIMPACT::acquire::Request::imageMemoryMode**\n"
		" of a request object can be modified. This can be used to configure one or more requests\n"
		" to use a user supplied memory. To use only a subset of the **mvIMPACT::acquire::Request**\n"
		" objects available the **mvIMPACT::acquire::ImageRequestControl::requestToUse** feature\n"
		" can be used.\n"
		"\n"
		" Only requests that are currently not used by the driver and are not locked\n"
		" because they contain image data that hasn't been processed can be set into\n"
		" configuration mode.\n"
		"\n"
		"\n"
		" Instead of calling this function directly for most cases it is much more convenient to use\n"
		" the functions **mvIMPACT::acquire::Request::attachUserBuffer** and **mvIMPACT::acquire::Request::detachUserBuffer**\n"
		" instead.\n"
		"\n"
		" User supplied buffers must follow the alignment and size requirements reported by versions of the\n"
		" function **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout**. Calling\n"
		" a version of this function will return all the information required to allocate buffers that\n"
		" can be used to capture data for the specified settings.\n"
		"\n"
		" When allocating memory on the heap, the complete buffer size is needed which is calculated like\n"
		" this:\n"
		"\n"
		" **size** + alignment\n"
		"\n"
		"\n"
		" The address passed to the request object must be aligned already!\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     Device* pDev = getDevicePointerFromSomewhere()\n"
		"     FunctionInterface fi( pDev );\n"
		"     ImageRequestControl irc( pDev );\n"
		"     int bufferSize = 0;\n"
		"     int bufferAlignment = 0;\n"
		"     const TDMR_ERROR result = static_castTDMR_ERROR( fi.getCurrentCaptureBufferLayout( irc, bufferSize, bufferAlignment ) );\n"
		"     Request* pRequest = fi.getRequest( 0 );\n"
		"     // the buffer assigned to the request object must be aligned accordingly\n"
		"     // the size of the user supplied buffer MUST NOT include the additional size\n"
		"     // caused by the alignment\n"
		"     if( pRequest-attachUserBuffer( getAlignedMemoryPtr( bufferSize, bufferAlignment ), bufferSize ) == DMR_NO_ERROR )\n"
		"     {\n"
		"       irc.requestToUse.write( 0 ); // use the buffer just configured for the next image request\n"
		"       // now the next image will be captured into the user supplied memory\n"
		"       fi.imageRequestSingle( irc ); // this will send request '0' to the driver\n"
		"       // wait for the buffer. Once it has been returned by the driver AND the user buffer shall no\n"
		"       // longer be used call\n"
		"       if( pRequest-detachUserBuffer() != DMR_NO_ERROR )\n"
		"       {\n"
		"         // handle error\n"
		"       }\n"
		"       // now this request will use internal memory again.\n"
		"     }\n"
		"     else\n"
		"     {\n"
		"        // handle error\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"There is currently no way to deal with alignment in Java when capturing into user supplied(thus managed) memory! Suggestions welcome!\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     import java.nio.ByteBuffer;\n"
		"\n"
		"    // ...\n"
		"\n"
		"     Device pDev = getDevicePointerFromSomewhere()\n"
		"     FunctionInterface fi = new FunctionInterface( pDev );\n"
		"     ImageRequestControl irc = new ImageRequestControl( pDev );\n"
		"     int[] bufferSize = {0};\n"
		"     int[] bufferAlignment = {0};\n"
		"     if( fi.getCurrentCaptureBufferLayout( irc, bufferSize, bufferAlignment ) == TDMR_ERROR.DMR_NO_ERROR )\n"
		"     {\n"
		"       Request pRequest = fi.getRequest( 0 );\n"
		"       // the buffer assigned to the request object must be aligned accordingly\n"
		"       // the size of the user supplied buffer MUST NOT include the additional size\n"
		"       // caused by the alignment\n"
		"       ByteBuffer pBuffer = ByteBuffer.allocateDirect( bufferSize[0] + bufferAlignment[0] ); // todo: There is currently no way to deal with alignment in Java! Suggestions welcome!\n"
		"       if( pRequest.attachUserBuffer( pBuffer ) == TDMR_ERROR.DMR_NO_ERROR )\n"
		"       {\n"
		"         irc.getRequestToUse().write( 0 ); // use the buffer just configured for the next image request\n"
		"         // now the next image will be captured into the user supplied memory\n"
		"         fi.imageRequestSingle( irc ); // this will send request '0' to the driver\n"
		"         // wait for the buffer. Once it has been returned by the driver AND the user buffer shall no\n"
		"         // longer be used call\n"
		"         if( pRequest.detachUserBuffer() != TDMR_ERROR.DMR_NO_ERROR )\n"
		"         {\n"
		"           // handle error\n"
		"         }\n"
		"         // now this request will use internal memory again.\n"
		"       }\n"
		"       else\n"
		"       {\n"
		"          // handle error\n"
		"       }\n"
		"     }\n"
		"     else\n"
		"     {\n"
		"        // handle error\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     pDev = getDevicePointerFromSomewhere()\n"
		"     fi = acquire.FunctionInterface(pDev)\n"
		"     irc = acquire.ImageRequestControl(pDev)\n"
		"     # this function returns a list containing [result, size, alignment]\n"
		"     results = fi.getCurrentCaptureBufferLayout(irc)\n"
		"     if results[0] == int(acquire.DMR_NO_ERROR):\n"
		"       pRequest = fi.getRequest(0)\n"
		"       # the buffer assigned to the request object must be aligned accordingly\n"
		"       # the size of the user supplied buffer MUST NOT include the additional size\n"
		"       # caused by the alignment\n"
		"       if pRequest.attachUserBuffer(getAlignedMemoryPtr(results[1], results[2] ), results[2]) == int(acquire.DMR_NO_ERROR):\n"
		"         irc.requestToUse.write(0) # use the buffer just configured for the next image request\n"
		"         # now the next image will be captured into the user supplied memory\n"
		"         fi.imageRequestSingle(irc) # this will send request '0' to the driver\n"
		"         # wait for the buffer. Once it has been returned by the driver AND the user buffer shall no\n"
		"         # longer be used call\n"
		"         if pRequest.detachUserBuffer() != TDMR_ERROR.DMR_NO_ERROR:\n"
		"           # handle error\n"
		"         # now this request will use internal memory again.\n"
		"       else:\n"
		"          # handle error\n"
		"     else:\n"
		"        # handle error\n"
		"}\n"
		"\n"
		" A request that is in configuration mode can't be sent to the driver for acquisition until\n"
		" **mvIMPACT::acquire::Request::unlock** or **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock** has been called again.\n"
		" By using **mvIMPACT::acquire::Request::attachUserBuffer** and **mvIMPACT::acquire::Request::detachUserBuffer** this locking\n"
		" and unlocking is done internally thus the application does not need to worry about this.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Request::configure**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::attachUserBuffer**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::detachUserBuffer**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestReset**\n"
		"\n"
		"Since: 1.10.31\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A const pointer to the request object to configure\n"
		""},
	 { "FunctionInterface_imageRequestResultQueueElementCount", _wrap_FunctionInterface_imageRequestResultQueueElementCount, METH_VARARGS, "\n"
		" Returns the number of **mvIMPACT::acquire::Request** objects in the result queue .\n"
		" This functions queries the number of **mvIMPACT::acquire::Request** objects currently in the result queue that are available for pickup. This number reflects the number of\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor** calls that could be executed afterwards the would return with a valid **mvIMPACT::acquire::Request**\n"
		" object immediately without waiting!\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStart**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStop**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestReset**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**\n"
		"\n"
		" **mvIMPACT::acquire::Request::configure**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**\n"
		"\n"
		"Since: 2.9.0\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - The number of **mvIMPACT::acquire::Request** objects in the result queue if successful.\n"
		"     - **mvIMPACT::acquire::DMR_INVALID_QUEUE_SELECTION** if the selected result queue does not exist.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type queueNr: int\n"
		":param queueNr: [in] The result queue to be queried.\n"
		""},
	 { "FunctionInterface_imageRequestReset", _wrap_FunctionInterface_imageRequestReset, METH_VARARGS, "\n"
		" Deletes all requests currently queued for the specified **mvIMPACT::acquire::ImageRequestControl**.\n"
		" This function will terminate all running image acquisitions associated with the queue\n"
		" bound to the specified image request control and in addition to that\n"
		" will empty the queue of pending image requests for that queue. Also all requests that reside in the\n"
		" result queue and have not been picked up by the application will be unlocked and removed from the\n"
		" result queue. So after this function returns only the requests currently in possession of the\n"
		" application (so requests that have been picked up by successful calls to **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**\n"
		" that have **NOT** been unlocked) need to be handled. All other requests are in a state where they\n"
		" can be queued for an acquisition again.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::configure**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type requestCtrlNr: int\n"
		":param requestCtrlNr: [in] The **mvIMPACT::acquire::ImageRequestControl** for which all the requests shall be cancelled.\n"
		":type mode: int\n"
		":param mode: [in] Currently unsupported. MUST be set 0.\n"
		""},
	 { "FunctionInterface_imageRequestUnlock", _wrap_FunctionInterface_imageRequestUnlock, METH_VARARGS, "\n"
		" Unlocks the request for the driver again.\n"
		"Notes: \n"
		" Another version of this function is available that might be nicer to use depending on personal\n"
		" preferences and use case: **mvIMPACT::acquire::Request::unlock**. Unlocking a certain request\n"
		" might be nicer by using this function, e.g. unlocking **ALL** requests in a loop is probably easier\n"
		" done by writing\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     Device* pDev = getDevicePointerFromSomewhere()\n"
		"     FunctionInterface fi( pDev );\n"
		"     const int rc = static_cast int ( fi.requestCount() );\n"
		"     for( int i=0; irc; i++ )\n"
		"     {\n"
		"       fi.imageRequestUnlock( i );\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     Device pDev = getDevicePointerFromSomewhere()\n"
		"     FunctionInterface fi = new FunctionInterface( pDev );\n"
		"     final long rc = fi.requestCount();\n"
		"     for( long i=0; irc; i++ )\n"
		"     {\n"
		"       fi.imageRequestUnlock( ( int )i );\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     pDev = getDevicePointerFromSomewhere()\n"
		"     fi = acquire.FunctionInterface(pDev)\n"
		"     rc = fi.requestCount()\n"
		"     for i in range(rc):\n"
		"       fi.imageRequestUnlock(i)\n"
		"}\n"
		"\n"
		" To ensure that no image data is overwritten by another image request while the user still\n"
		" deals with the image from a previous acquisition each image buffer will be locked by the driver when\n"
		" it is returned to the user by a call to **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**.\n"
		" No new image will be captured into the same buffer until the user unlocks the buffer again\n"
		" by calling **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**.\n"
		"\n"
		"\n"
		" After unlocking a request it is no longer guaranteed that the memory once referenced by the\n"
		" request and the image buffer belonging to it stays valid, so do **NEVER** try to access\n"
		" memory belonging to an unlocked request object. If you need to copy the image buffer or\n"
		" modify it in any other way, do everything you have to do **BEFORE** calling this function!\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestReset**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::configure**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DEV_REQUEST_CANT_BE_UNLOCKED** if the request number defined by *nr* is currently not owned by the application (either already unlocked or queued for acquisition).\n"
		"     - **mvIMPACT::acquire::DMR_INPUT_BUFFER_TOO_SMALL** if the request number defined by *nr* has been configured to capture into a user supplied buffer but the buffer is too small to acquire data into.\n"
		"     - **mvIMPACT::acquire::DEV_REQUEST_BUFFER_MISALIGNED** if the request number defined by *nr* has been configured to capture into a user supplied buffer but this buffer is not aligned in order to the alignment restrictions reported by this driver/device combination.\n"
		"     - **mvIMPACT::acquire::DEV_REQUEST_BUFFER_INVALID** if the request number defined by *nr* has been configured to capture into a user supplied buffer but an invalid (NULL) pointer has been attached to the request.\n"
		"     - **mvIMPACT::acquire::DEV_INVALID_REQUEST_NUMBER** if the request number defined by *nr* is invalid (out of bounds).\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the request to unlock. This is typically a value returned from a call to **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**.\n"
		""},
	 { "FunctionInterface_imageRequestWaitFor", _wrap_FunctionInterface_imageRequestWaitFor, METH_VARARGS, "\n"
		" Waits for a request object to become ready.\n"
		" This function waits for a request object previously sent to the capture device by calling\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**. When a new request became ready during\n"
		" the period of time specified by the *timeout_ms* parameter this request is extracted from the\n"
		" result queue and is returned to the user so the same request can not be returned twice until\n"
		" it has been processed and unlocked by the application.\n"
		"\n"
		" Notes: Whenever a **mvIMPACT::acquire::Request** is returned to the user the image data\n"
		" described by the **mvIMPACT::acquire::Request** remains valid until the user unlocks\n"
		" the image buffer again or the driver is closed.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::getRequest**\n"
		" :rtype: int\n"
		" :return: If the return value is greater than or equal to zero, the return value is the request number of the\n"
		"     image request in the interface's internal array of image requests. In this case the user\n"
		"     can call **mvIMPACT::acquire::FunctionInterface::getRequest** to get access to the\n"
		"     results.\n"
		"\n"
		"    If the result is negative, the return value is an error code.\n"
		"     The error code that is returned in most cases will be **mvIMPACT::acquire::DEV_WAIT_FOR_REQUEST_FAILED**.\n"
		"     To find out possible reasons for this error, look at the corresponding explanation.\n"
		"\n"
		":type timeout_ms: int\n"
		":param timeout_ms: [in] The maximum wait time in milliseconds (ms) for this request to become ready. If *timeout_ms* is '-1', the function's timeout interval never elapses. If the result queue specified by the *queueNr* parameter already contains a request when calling this function the function will return immediately. Please note that each request has its own timeout that is independent from this wait timeout, thus this function will return with a valid request after the timeout for this request has elapsed even if e.g. a trigger has not been detected. For detailed information on the interaction of the timeout of this function and the timeout of a request please refer to the chapter 'ImageAcquisition_capture_AcquiringData' in the C++ section.\n"
		":type queueNr: int\n"
		":param queueNr: [in] The queue where to wait for the request. The number of request queues available depends on the number of video channels offered by the device. The queue a processed request ends up in can be defined by setting the property **mvIMPACT::acquire::ImageRequestControl::resultQueue** **BEFORE** calling **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**.\n"
		""},
	 { "FunctionInterface_getCurrentCaptureBufferLayout", _wrap_FunctionInterface_getCurrentCaptureBufferLayout, METH_VARARGS, "\n"
		" Returns information about the current capture buffer requirements.\n"
		" When an application wants to provide capture buffers, this function will be needed in order to\n"
		" get information on how the capture buffers must be constructed.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" To find out more about capturing to user memory please refer to the application\n"
		" 'CaptureToUserMemory.cpp'\n"
		" }\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::Request::configure**\n"
		"\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type imageRequestControl: :py:class:`ImageRequestControl`\n"
		":param imageRequestControl: [in] A reference to the **mvIMPACT::acquire::ImageRequestControl** object containing the setting for which the current capture buffer layout shall be queried. The setting can be defined via the property **mvIMPACT::acquire::ImageRequestControl::setting**.\n"
		":type size: int\n"
		":param size: [out] On a successful call this variable will receive the size needed for capturing into user supplied buffers that use the current settings.\n"
		":type alignment: int\n"
		":param alignment: [out] On a successful call this variable will receive the alignment needed for capturing into user supplied buffers that use the current settings.\n"
		""},
	 { "FunctionInterface_isRequestNrValid", _wrap_FunctionInterface_isRequestNrValid, METH_VARARGS, "\n"
		"Check if *nr* specifies a valid **mvIMPACT::acquire::Request**.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if *nr* specifies a valid request.\n"
		"    - false otherwise\n"
		""},
	 { "FunctionInterface_isSettingAvailable", _wrap_FunctionInterface_isSettingAvailable, METH_VARARGS, "\n"
		" Checks if a certain setting is available under the specified location.\n"
		" This function checks if a certain setting is available under the specified location.\n"
		"\n"
		" Since: 2.19.0\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name or the full path under where the setting is located.\n"
		":type storageLocation: int\n"
		":param storageLocation: [in] The location of the setting.\n"
		":type scope: int\n"
		":param scope: [in] Specifies the scope of this operation.\n"
		""},
	 { "FunctionInterface_loadSetting", _wrap_FunctionInterface_loadSetting, METH_VARARGS, "\n"
		" Loads a previously stored setting.\n"
		" This function can be used to restore a previously stored setting again.\n"
		"\n"
		" To load a setting from a file the **mvIMPACT::acquire::sfFile** should be specified\n"
		" as part of *storageFlags*. To load a setting from a platform specific location\n"
		" such as the Registry under Windows(C) **mvIMPACT::acquire::sfNative** should be\n"
		" specified. It's not allowed to combine **mvIMPACT::acquire::sfFile** and\n"
		" **mvIMPACT::acquire::sfNative** for this operation.\n"
		"\n"
		" Since mvIMPACT Acquire 2.9.0 GenICam devices will be able to save their properties in an XML File, only if the properties have the **streamable** attribute set (for more information refer to the GenICam standard specification (\"http://www.emva.org/standards-technology/genicam/genicam-downloads/\")). Properties with no **streamable** attribute set, will be silently ignored when saving, which means they will **not** be saved in the XML file. For MATRIX VISION GenICam devices, starting with firmware version 1.6.414 the **streamable** attribute is set for all the necessary properties.\n"
		"\n"
		"\n"
		"\n"
		"\n"
		" Since mvIMPACT Acquire 2.9.0 and again in version 2.11.0 storing and loading of camera settings in an XML file for the **mvIMPACT::acquire::dilGenICam**\n"
		" interface layout has been updated. As a result XML files created with newer versions of mvIMPACT Acquire might **not**\n"
		" be readable on systems with older version of mvIMPACT Acquire installed. XML files created on systems\n"
		" with earlier versions of mvIMPACT Acquire will always be readable this or newer versions. See the following table for details.\n"
		"\n"
		"   |mvIMPACT Acquire Version|Loading an XML settings file created with mvIMPACT Acquire version < 2.9.0|Loading an XML settings file created with mvIMPACT Acquire version 2.9.0 - 2.10.1|Loading an XML settings file created with mvIMPACT Acquire version 2.11.0 or later\n"
		"   -----------------------\n"
		"   | < 2.9.0 | YES | NO | NO\n"
		"   -----------------------\n"
		"   | 2.9.0 - 2.10.1 | YES | YES | NO\n"
		"   -----------------------\n"
		"   | >= 2.11.0 | YES | YES | YES\n"
		"\n"
		"\n"
		" Since mvIMPACT Acquire 2.28.0 it is possible for devices operated in the **::dilGenICam** interface layout to store settings including\n"
		" sequencer sets and user sets (see SFNC for details) data by specifying the **::sfProcessGenICamSequencerData** and/or **::sfProcessGenICamUserSetData**\n"
		" during the storage operation. Settings stored like this cannot be loaded by previous mvIMPACT Acquire versions.\n"
		"\n"
		" Notes: For devices operated in the **mvIMPACT::acquire::dilGenICam** interface layout further restriction apply: Settings created with a certain product type can only\n"
		" be used with other devices belonging to the exact same type as defined by the property mvIMPACT::acquire::Device::product inside the device list (the one device specific property list that\n"
		" is accessible without initialising the device before). Even if a setting can be used with various firmware versions it is recommended to use one setting\n"
		" for multiple devices all updated to the very same firmware version to avoid compatibility problems.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::saveSetting**.\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name or the full path under where the setting is located.\n"
		":type storageFlags: int\n"
		":param storageFlags: [in] The flags which define which information shall be read from the location and how this information shall be interpreted.\n"
		":type scope: int\n"
		":param scope: [in] Specifies where the information is located.\n"
		""},
	 { "FunctionInterface_loadSettingFromStack", _wrap_FunctionInterface_loadSettingFromStack, METH_O, "\n"
		" loads the last setting from the setting stack.\n"
		" This function loads the last setting from the setting stack.\n"
		"\n"
		" See **mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack** for an example how to use this feature.\n"
		"\n"
		" See also **mvIMPACT::acquire::FunctionInterface::loadSetting** to find out which features of a GenICam device\n"
		" are stored in a setting and which are not!\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack**\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::deleteSettingFromStack**\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::loadAndDeleteSettingFromStack**\n"
		"\n"
		"\n"
		" Since: 2.19.0\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		""},
	 { "FunctionInterface_loadAndDeleteSettingFromStack", _wrap_FunctionInterface_loadAndDeleteSettingFromStack, METH_O, "\n"
		" loads the last setting from the setting stack and then removes this setting from the stack.\n"
		" This function loads the last setting from the setting stack and then removes this setting from the stack.\n"
		"\n"
		" See **mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack** for an example how to use this feature.\n"
		"\n"
		" See also **mvIMPACT::acquire::FunctionInterface::loadSetting** to find out which features of a GenICam device\n"
		" are stored in a setting and which are not!\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack**\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::deleteSettingFromStack**\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::loadSettingFromStack**\n"
		"\n"
		"\n"
		" Since: 2.19.0\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		""},
	 { "FunctionInterface_loadSettingFromDefault", _wrap_FunctionInterface_loadSettingFromDefault, METH_VARARGS, "\n"
		" Loads the default settings.\n"
		" This function will try to load the settings from a default location. This function\n"
		" can only succeed if a setting has been stored previously by a call to\n"
		" **mvIMPACT::acquire::FunctionInterface::saveSettingToDefault**.\n"
		"\n"
		" There has been an incompatible change when loading settings in version 2.9.0 and 2.11.0 of mvIMPACT Acquire as well as in version 2.28.0. See **mvIMPACT::acquire::FunctionInterface::loadSetting** for details.\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type scope: int\n"
		":param scope: [in] Specifies where the information is located.\n"
		""},
	 { "FunctionInterface_requestCount", _wrap_FunctionInterface_requestCount, METH_O, "\n"
		"Returns the number of available request objects.\n"
		"See also: \n"
		"**mvIMPACT::acquire::SystemSettings::requestCount** to change the number of request objects\n"
		"\n"
		":rtype: int\n"
		":return: Returns the number of available request objects.\n"
		""},
	 { "FunctionInterface_saveCurrentSettingOnStack", _wrap_FunctionInterface_saveCurrentSettingOnStack, METH_VARARGS, "\n"
		" Saves the current setting on the setting stack.\n"
		" This function saves the current setting on the setting stack. Together which the\n"
		" functions mentioned below this implements a stack for capture settings. This can\n"
		" become handy when entering a section of code that might modify the current capture settings\n"
		" in various ways and depending on the result these modifications shall either be kept or\n"
		" discarded at the end of the operation.\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // ...\n"
		"     enum TResult\n"
		"     {\n"
		"       rApply,\n"
		"       rDiscard\n"
		"     };\n"
		"     // ...\n"
		"     FunctionInterface fi = getFunctionInterfaceFromSomewhere();\n"
		"     fi.saveCurrentSettingOnStack();\n"
		"     switch( enterSectionThatModifiesDeviceSettings() )\n"
		"     {\n"
		"     case rDiscard:\n"
		"         fi.loadAndDeleteSettingFromStack(); // revert all changes just applied without worrying about what these changes actually are\n"
		"         break;\n"
		"     case rApply:\n"
		"         fi.deleteSettingFromStack(); // remove the setting from the stack, but keep changes\n"
		"         break;\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     // ...\n"
		"     final int Apply = 1;\n"
		"     final int Discard = 2;\n"
		"     // ...\n"
		"     FunctionInterface fi = getFunctionInterfaceFromSomewhere();\n"
		"     fi.saveCurrentSettingOnStack();\n"
		"     final int option = enterSectionThatModifiesDeviceSettings();\n"
		"     if( option == Discard )\n"
		"     {\n"
		"       fi.loadAndDeleteSettingFromStack(); // revert all changes just applied without worrying about what these changes actually are\n"
		"     }\n"
		"     else if( option == Apply )\n"
		"     {\n"
		"       fi.deleteSettingFromStack(); // remove the setting from the stack, but keep changes\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"DISCARD_SETTING = 1\n"
		"APPLY_SETTING = 2\n"
		"fi = getFunctionInterfaceFromSomewhere()\n"
		"fi.saveCurrentSettingOnStack()\n"
		"option = enterSectionThatModifiesDeviceSettings()\n"
		"if option == DISCARD_SETTING: # discard\n"
		"   fi.loadAndDeleteSettingFromStack() # revert all changes just applied without worrying about what these changes actually are\n"
		"elif option == APPLY_SETTING: # apply\n"
		"   fi.deleteSettingFromStack() # remove the setting from the stack, but keep changes\n"
		"}\n"
		"\n"
		" The stack makes use of mvIMPACT Acquires ability to store capture settings in the memory of\n"
		" the current process. Once the last instance of this **mvIMPACT::acquire::FunctionInterface**\n"
		" object is deleted all settings pushed on this stack will be deleted automatically.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::FunctionInterface::deleteSettingFromStack**\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::loadSettingFromStack**\n"
		"\n"
		"**mvIMPACT::acquire::FunctionInterface::loadAndDeleteSettingFromStack**\n"
		"\n"
		"\n"
		" Since: 2.19.0\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type storageFlags: int\n"
		":param storageFlags: [in] The flags which define which information shall be stored and how this information shall be stored.\n"
		""},
	 { "FunctionInterface_saveSetting", _wrap_FunctionInterface_saveSetting, METH_VARARGS, "\n"
		" Stores the current settings.\n"
		" This function can be used to store the current settings either in an XML-file or\n"
		" (under Windows(C)) into the Registry. A setting contains all the values set\n"
		" for properties that control the overall way an image is acquired( e.g. the exposure time, etc.).\n"
		"\n"
		" To store a setting in a file the **mvIMPACT::acquire::sfFile** should be specified\n"
		" as part of *storageFlags*. To store a setting in a platform specific location\n"
		" such as the Registry under Windows(C) **mvIMPACT::acquire::sfNative** should be\n"
		" specified. Both flags can be combined. In that case the same setting will be stored in a\n"
		" file **AND** in a platform specific location if these location differ (platform dependent!).\n"
		"\n"
		" There has been an incompatible change when loading settings in version 2.9.0 and 2.11.0 of mvIMPACT Acquire as well as in version 2.28.0. See **mvIMPACT::acquire::FunctionInterface::loadSetting** for details.\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name or the full path under which this setting shall be stored\n"
		":type storageFlags: int\n"
		":param storageFlags: [in] The flags which define which information shall be stored and how this information shall be stored.\n"
		":type scope: int\n"
		":param scope: [in] Specifies where the information shall be stored.\n"
		""},
	 { "FunctionInterface_saveSettingToDefault", _wrap_FunctionInterface_saveSettingToDefault, METH_VARARGS, "\n"
		" Stores the current settings under a default location.\n"
		" Under Windows(C) this will be in the Registry. A setting contains all the values set\n"
		" for properties that control the overall way an image is acquired( e.g. the exposure time, etc.).\n"
		"\n"
		" There has been an incompatible change when loading settings in version 2.9.0 and 2.11.0 of mvIMPACT Acquire as well as in version 2.28.0. See **mvIMPACT::acquire::FunctionInterface::loadSetting** for details.\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type scope: int\n"
		":param scope: [in] Specifies where the information shall be stored.\n"
		""},
	 { "FunctionInterface_imageRequestSingle", _wrap_FunctionInterface_imageRequestSingle, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Sends an image request to the **mvIMPACT::acquire::Device** driver.\n"
		" This functions sends a single image request to the capture device. To wait for the image\n"
		" to become ready call the function\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**.\n"
		"\n"
		"\n"
		" In order to make sure that no image data is lost, it is important to understand how\n"
		" the request mechanism works. The driver works with a fixed number of **mvIMPACT::acquire::Request**\n"
		" objects. The number of **mvIMPACT::acquire::Request** objects available to the driver can be set\n"
		" by modifying the property **mvIMPACT::acquire::SystemSettings::requestCount**. Each **mvIMPACT::acquire::Request** will\n"
		" consume a certain amount of memory. Once an image has been captured by the **mvIMPACT::acquire::Request**,\n"
		" this amount will be slightly more than the image itself needs in memory, so modify this\n"
		" parameter gently. On the other hand, it's necessary to have more than a single request\n"
		" in order to ensure a lossless acquisition. E.g. when working with free running cameras an\n"
		" image might be lost because while an image has been captured and is being processed, the next\n"
		" vertical sync. pulse is already missed before the **mvIMPACT::acquire::Request** is unlocked again.\n"
		"\n"
		" Notes: \n"
		" When **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is\n"
		" set to **mvIMPACT::acquire::assbUser** several calls to **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**\n"
		" will **NOT** start the data acquisition! After requests have been sent down to the driver,\n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStart** must be called. For performance reasons some device drivers\n"
		" will **NOT** allow to request data into buffers which have not been known to the driver when **mvIMPACT::acquire::FunctionInterface::acquisitionStart**\n"
		" was called, thus before starting the acquisition, **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**\n"
		" should be called as many times as there are request objects.\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStart**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStop**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestReset**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::configure**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DEV_NO_FREE_REQUEST_AVAILABLE** if all mvIMPACT::acquire::Request objects are currently in use (either owned by the user or queued for acquisition).\n"
		"     - **mvIMPACT::acquire::DEV_INVALID_REQUEST_NUMBER** if the request number defined by the property **ImageRequestControl::requestToUse** is invalid (out of bounds).\n"
		"     - **mvIMPACT::acquire::DEV_REQUEST_ALREADY_IN_USE** if the request number defined by the property **ImageRequestControl::requestToUse** is already in use (either owned by the user or queued for acquisition).\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Sends an image request to the **mvIMPACT::acquire::Device** driver.\n"
		" This functions sends a single image request to the capture device. To wait for the image\n"
		" to become ready call the function\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**.\n"
		"\n"
		"\n"
		" In order to make sure that no image data is lost, it is important to understand how\n"
		" the request mechanism works. The driver works with a fixed number of **mvIMPACT::acquire::Request**\n"
		" objects. The number of **mvIMPACT::acquire::Request** objects available to the driver can be set\n"
		" by modifying the property **mvIMPACT::acquire::SystemSettings::requestCount**. Each **mvIMPACT::acquire::Request** will\n"
		" consume a certain amount of memory. Once an image has been captured by the **mvIMPACT::acquire::Request**,\n"
		" this amount will be slightly more than the image itself needs in memory, so modify this\n"
		" parameter gently. On the other hand, it's necessary to have more than a single request\n"
		" in order to ensure a lossless acquisition. E.g. when working with free running cameras an\n"
		" image might be lost because while an image has been captured and is being processed, the next\n"
		" vertical sync. pulse is already missed before the **mvIMPACT::acquire::Request** is unlocked again.\n"
		"\n"
		" Notes: \n"
		" When **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is\n"
		" set to **mvIMPACT::acquire::assbUser** several calls to **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**\n"
		" will **NOT** start the data acquisition! After requests have been sent down to the driver,\n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStart** must be called. For performance reasons some device drivers\n"
		" will **NOT** allow to request data into buffers which have not been known to the driver when **mvIMPACT::acquire::FunctionInterface::acquisitionStart**\n"
		" was called, thus before starting the acquisition, **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**\n"
		" should be called as many times as there are request objects.\n"
		" See also: \n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStart**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::acquisitionStop**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestReset**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::unlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,\n"
		"\n"
		" **mvIMPACT::acquire::Request::configure**,\n"
		"\n"
		" **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DEV_NO_FREE_REQUEST_AVAILABLE** if all mvIMPACT::acquire::Request objects are currently in use (either owned by the user or queued for acquisition).\n"
		"     - **mvIMPACT::acquire::DEV_INVALID_REQUEST_NUMBER** if the request number defined by the property **ImageRequestControl::requestToUse** is invalid (out of bounds).\n"
		"     - **mvIMPACT::acquire::DEV_REQUEST_ALREADY_IN_USE** if the request number defined by the property **ImageRequestControl::requestToUse** is already in use (either owned by the user or queued for acquisition).\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type imageRequestControl: :py:class:`ImageRequestControl`\n"
		":param imageRequestControl: [in] The **mvIMPACT::acquire::ImageRequestControl** object to be used for this request. **mvIMPACT::acquire::ImageRequestControl** objects define (among other things), which setting will be used for this image acquisition (via the property **mvIMPACT::acquire::ImageRequestControl::setting)**.\n"
		""},
	 { "FunctionInterface_swigregister", FunctionInterface_swigregister, METH_O, NULL},
	 { "FunctionInterface_swiginit", FunctionInterface_swiginit, METH_VARARGS, NULL},
	 { "new_Info", _wrap_new_Info, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::Info** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "Info_deviceDriverVersion_get", _wrap_Info_deviceDriverVersion_get, METH_O, "\n"
		"An integer property **(read-only)** containing the device driver version used by this device.\n"
		"This is the version of the underlying hardware driver. For device drivers that don't have another\n"
		"user mode driver below the interface driver this property will contain the same version information\n"
		"as the property **mvIMPACT::acquire::Info::driverVersion**.\n"
		""},
	 { "Info_driverDate_get", _wrap_Info_driverDate_get, METH_O, " A string property **(read-only)** containing the date the device driver has been compiled."},
	 { "Info_driverVersion_get", _wrap_Info_driverVersion_get, METH_O, " A string property **(read-only)** containing the version number of the device driver."},
	 { "Info_state_get", _wrap_Info_state_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** containing the current state of this device.\n"
		"This property e.g. provides information about the current state of the device. For USB devices this can e.g. indicate whether\n"
		"a device is currently plugged into the system or not.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceState**.\n"
		"\n"
		"**GenICam/GenTL** **device** **specific**:\n"
		"In order to reduce the amount of network traffic to a minimum, this property will only be updated automatically\n"
		"for network devices if the property **mvIMPACT::acquire::Device::registerErrorEvent** is set to\n"
		"**mvIMPACT::acquire::bTrue** (which is the default behaviour). If the IP addresses stay the same the\n"
		"connection is automatically re-established then once the device is detected by the driver again.\n"
		"However if the IP address of the device and/or the network adapter of the system it is used from changes\n"
		"**mvIMPACT::acquire::DeviceManager::updateDeviceList()**\n"
		"must be called regardless of the value of **mvIMPACT::acquire::Device::registerErrorEvent** before a device\n"
		"that was lost can re-establish a connection to the capture driver.\n"
		""},
	 { "Info_loadedSettings_get", _wrap_Info_loadedSettings_get, METH_O, " A string property **(read-only)** containing the name of the setting currently loaded."},
	 { "Info_logFile_get", _wrap_Info_logFile_get, METH_O, " A string property **(read-only)** containing the name and the full path of the current log-file for this device."},
	 { "Info_systemPhysicalProcessorCount_get", _wrap_Info_systemPhysicalProcessorCount_get, METH_O, "\n"
		" An integer property **(read-only)** containing the number of physical processors detected in the current system.\n"
		"Since: 2.44.0\n"
		""},
	 { "Info_systemLogicalProcessorCount_get", _wrap_Info_systemLogicalProcessorCount_get, METH_O, "\n"
		" An integer property **(read-only)** containing the number of logical processors detected in the current system.\n"
		"Since: 2.44.0\n"
		""},
	 { "Info_captureBufferAlignment_get", _wrap_Info_captureBufferAlignment_get, METH_O, " An integer property **(read-only)** containing the capture buffer alignment in bytes needed by this device driver."},
	 { "Info_recommendedListsForUIs_get", _wrap_Info_recommendedListsForUIs_get, METH_O, " A string property **(read-only)** containing an array of full search paths to lists which are recommended to be displayed in a user interface that is created dynamically."},
	 { "delete_Info", _wrap_delete_Info, METH_O, NULL},
	 { "Info_swigregister", Info_swigregister, METH_O, NULL},
	 { "Info_swiginit", Info_swiginit, METH_VARARGS, NULL},
	 { "new_BasicDeviceSettings", _wrap_new_BasicDeviceSettings, METH_VARARGS, "\n"
		" brief Constructs a new **mvIMPACT::acquire::BasicDeviceSettings** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "BasicDeviceSettings_basedOn_get", _wrap_BasicDeviceSettings_basedOn_get, METH_O, "\n"
		"A string property **(read-only)** containing the name of the setting this setting is based on.\n"
		"Since: 1.12.67\n"
		""},
	 { "BasicDeviceSettings_imageRequestTimeout_ms_get", _wrap_BasicDeviceSettings_imageRequestTimeout_ms_get, METH_O, "\n"
		" An integer property defining the maximum time to wait for an image in ms.\n"
		"Since mvIMPACT Acquire 2.32.0 the default value for this property has been changed! See 'KnownIssuesPage_ApplicationTerminationWaitingForRequests' for details.\n"
		"\n"
		" When this property is set to 0 the timeout never elapses. If the timeout this property\n"
		" defines elapses the currently processed request will be returned to the user even if no data\n"
		" has been captured so far. The result structure of the request object should be examined in that\n"
		" case. Also this should be considered as an error from the users point of view in which case he\n"
		" should clean up the acquisition queue by calling **mvIMPACT::acquire::FunctionInterface::imageRequestReset**.\n"
		" Afterwards the capture loop can be restarted.\n"
		"\n"
		" Notes: \n"
		" It is crucial to understand that this is a timeout **PER REQUEST**! The timespan taken into account for the measurement\n"
		" starts when the driver begins to capture data into **this particular buffer**! So when queuing 4 buffers with a timeout of 3000\n"
		" ms each and no data being transmitted by the device for any reason will cause the last buffer to time out 3000*4 = 12000 ms AFTER\n"
		" the buffer has been queued and the acquisition has been started as the driver will wait for up to 3 seconds for each buffer that is\n"
		" being processed. When the device sends data this timeout does not affect the runtime behaviour at all. No additional delay is introduced\n"
		" by it when everything runs as planned.\n"
		""},
	 { "delete_BasicDeviceSettings", _wrap_delete_BasicDeviceSettings, METH_O, NULL},
	 { "BasicDeviceSettings_swigregister", BasicDeviceSettings_swigregister, METH_O, NULL},
	 { "BasicDeviceSettings_swiginit", BasicDeviceSettings_swiginit, METH_VARARGS, NULL},
	 { "TriggerControl_getDescription", _wrap_TriggerControl_getDescription, METH_O, " Returns a name of the trigger being configured."},
	 { "TriggerControl_triggerSoftware", _wrap_TriggerControl_triggerSoftware, METH_O, "\n"
		"Generates of software trigger command.\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "TriggerControl_triggerMode_get", _wrap_TriggerControl_triggerMode_get, METH_O, " Defines if the selected trigger is active."},
	 { "TriggerControl_triggerSource_get", _wrap_TriggerControl_triggerSource_get, METH_O, "\n"
		"Defines the signal that will cause the trigger event.\n"
		"Currently this property will define a translation dictionary that can e.g. be queried via a call to\n"
		"**mvIMPACT::acquire::PropertyI64::getTranslationDict**. The resulting translation dictionary can be used\n"
		"to select the desired trigger source either via a string or the associated 64 bit integer value.\n"
		""},
	 { "TriggerControl_triggerActivation_get", _wrap_TriggerControl_triggerActivation_get, METH_O, "\n"
		"An enumerated 64 bit integer property that defines the start condition for the selected trigger.\n"
		"Valid value will be 'RisingEdge', 'FallingEdge', 'AnyEdge', 'LevelLow' or 'LevelHigh'.\n"
		""},
	 { "TriggerControl_triggerDivider_get", _wrap_TriggerControl_triggerDivider_get, METH_O, "\n"
		"An integer property used to divide the number of incoming trigger pulses by an integer factor.\n"
		"E.g. setting this value to 2 would generate 5 internal trigger events from a 10 Hz external signal.\n"
		""},
	 { "TriggerControl_triggerDelayAbs_us_get", _wrap_TriggerControl_triggerDelayAbs_us_get, METH_O, " Specifies the absolute delay in microseconds (us) to apply after the trigger reception before effectively activating it."},
	 { "TriggerControl_triggerDelayLines_get", _wrap_TriggerControl_triggerDelayLines_get, METH_O, " Specifies the absolute delay in lines to apply after the trigger reception before effectively activating it."},
	 { "TriggerControl_triggerOverlap_get", _wrap_TriggerControl_triggerOverlap_get, METH_O, "\n"
		"Specifies the type trigger overlap permitted with the previous frame. This defines when a valid trigger will be accepted (or latched) for a new frame.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceTriggerOverlap**.\n"
		""},
	 { "delete_TriggerControl", _wrap_delete_TriggerControl, METH_O, NULL},
	 { "TriggerControl_swigregister", TriggerControl_swigregister, METH_O, NULL},
	 { "new_ImageDestination", _wrap_new_ImageDestination, METH_VARARGS, "\n"
		" brief Constructs a new **mvIMPACT::acquire::ImageDestination** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "ImageDestination_pixelFormat_get", _wrap_ImageDestination_pixelFormat_get, METH_O, "\n"
		"An enumerated integer property defining the pixel format of the resulting image.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageDestinationPixelFormat**.\n"
		""},
	 { "ImageDestination_scalerMode_get", _wrap_ImageDestination_scalerMode_get, METH_O, "\n"
		"An integer property defining whether the image is scaled or not.\n"
		"Notes: \n"
		"This feature is available for every device! However currently only **mvDELTA** / **mvSIGMA**\n"
		"devices provide hardware support for **REDUCING** the image size. In this case the scaled width\n"
		"and height must be divisible by 4. For every other device this\n"
		"will be done by a software filter and therefore will introduce additional CPU load. Increasing\n"
		"the image size will always be done in software. When using the scaler the property\n"
		"**mvIMPACT::acquire::Statistics::imageProcTime_s** can be used to observe the additional\n"
		"CPU time needed for the image processing.\n"
		""},
	 { "ImageDestination_scalerInterpolationMode_get", _wrap_ImageDestination_scalerInterpolationMode_get, METH_O, "\n"
		"An integer property defining the interpolation method used when the scaler is active.\n"
		"Notes: \n"
		"Whenever the property **mvIMPACT::acquire::ImageDestination::scalerMode** is set to\n"
		"**mvIMPACT::acquire::smOff** modifying or reading this property will have no effect.\n"
		"Call **Component::isVisible** to find out whether this property is currently active or not.\n"
		"\n"
		"\n"
		"Please see remarks under **mvIMPACT::acquire::ImageDestination::scalerMode**. The interpolation mode\n"
		"currently will only be used when scaling is **NOT** done by the hardware.\n"
		""},
	 { "ImageDestination_scalerAoiEnable_get", _wrap_ImageDestination_scalerAoiEnable_get, METH_O, "\n"
		"A boolean property defining whether an AOI, rather than the whole image, will be used for scaling.\n"
		"Notes: \n"
		"Whenever the property **mvIMPACT::acquire::ImageDestination::scalerAoiEnable** is set to\n"
		"**mvIMPACT::acquire::bTrue** the relevant AOI configuration properties will become visible.\n"
		""},
	 { "ImageDestination_scalerAoiHeight_get", _wrap_ImageDestination_scalerAoiHeight_get, METH_O, "\n"
		"An integer property defining the height of the AOI in pixel to be used for scaling.\n"
		"Notes: \n"
		"This property will be visible only when **mvIMPACT::acquire::ImageDestination::scalerAoiEnable**\n"
		"is set to **mvIMPACT::acquire::bTrue**.\n"
		""},
	 { "ImageDestination_scalerAoiStartX_get", _wrap_ImageDestination_scalerAoiStartX_get, METH_O, "\n"
		"An integer property defining the X-offset of the AOI in pixel to be used for the calculation.\n"
		"Notes: \n"
		"This property will be visible only when **mvIMPACT::acquire::ImageDestination::scalerAoiEnable**\n"
		"is set to **mvIMPACT::acquire::bTrue**.\n"
		""},
	 { "ImageDestination_scalerAoiStartY_get", _wrap_ImageDestination_scalerAoiStartY_get, METH_O, "\n"
		"An integer property defining the Y-offset of the AOI in pixel to be used for the calculation.\n"
		"Notes: \n"
		"This property will be visible only when **mvIMPACT::acquire::ImageDestination::scalerAoiEnable**\n"
		"is set to **mvIMPACT::acquire::bTrue**.\n"
		""},
	 { "ImageDestination_scalerAoiWidth_get", _wrap_ImageDestination_scalerAoiWidth_get, METH_O, "\n"
		"An integer property defining the width of the AOI in pixel to be used for the calculation.\n"
		"Notes: \n"
		"This property will be visible only when **mvIMPACT::acquire::ImageDestination::scalerAoiEnable**\n"
		"is set to **mvIMPACT::acquire::bTrue**.\n"
		""},
	 { "ImageDestination_imageWidth_get", _wrap_ImageDestination_imageWidth_get, METH_O, "\n"
		"An integer property defining the width of the scaled image.\n"
		"Notes: \n"
		"Whenever the property **mvIMPACT::acquire::ImageDestination::scalerMode** is set to\n"
		"**mvIMPACT::acquire::smOff** modifying or reading this property will have no effect.\n"
		"Call **Component::isVisible** to find out whether this property is currently active or not.\n"
		"\n"
		"\n"
		"Please see remarks under **mvIMPACT::acquire::ImageDestination::scalerMode**.\n"
		""},
	 { "ImageDestination_imageHeight_get", _wrap_ImageDestination_imageHeight_get, METH_O, "\n"
		"An integer property defining the height of the scaled image.\n"
		"Notes: \n"
		"Whenever the property **mvIMPACT::acquire::ImageDestination::scalerMode** is set to\n"
		"**mvIMPACT::acquire::smOff** modifying or reading this property will have no effect.\n"
		"Call **Component::isVisible** to find out whether this property is currently active or not.\n"
		"\n"
		"\n"
		"Please see remarks under **mvIMPACT::acquire::ImageDestination::scalerMode**.\n"
		""},
	 { "delete_ImageDestination", _wrap_delete_ImageDestination, METH_O, NULL},
	 { "ImageDestination_swigregister", ImageDestination_swigregister, METH_O, NULL},
	 { "ImageDestination_swiginit", ImageDestination_swiginit, METH_VARARGS, NULL},
	 { "new_RequestInfoConfiguration", _wrap_new_RequestInfoConfiguration, METH_VARARGS, "\n"
		" brief Constructs a new **mvIMPACT::acquire::RequestInfoConfiguration** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "RequestInfoConfiguration_frameNr_get", _wrap_RequestInfoConfiguration_frameNr_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the frame number information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "RequestInfoConfiguration_timeStamp_us_get", _wrap_RequestInfoConfiguration_timeStamp_us_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the time stamp(us) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "RequestInfoConfiguration_settingUsed_get", _wrap_RequestInfoConfiguration_settingUsed_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the 'setting used' information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "RequestInfoConfiguration_frameID_get", _wrap_RequestInfoConfiguration_frameID_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the frame ID information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "RequestInfoConfiguration_exposeStart_us_get", _wrap_RequestInfoConfiguration_exposeStart_us_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the exposure start(us) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "RequestInfoConfiguration_exposeTime_us_get", _wrap_RequestInfoConfiguration_exposeTime_us_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the exposure time(us) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "RequestInfoConfiguration_gain_dB_get", _wrap_RequestInfoConfiguration_gain_dB_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the gain(dB) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "RequestInfoConfiguration_videoChannel_get", _wrap_RequestInfoConfiguration_videoChannel_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the video channel information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "RequestInfoConfiguration_missingData_pc_get", _wrap_RequestInfoConfiguration_missingData_pc_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the missing data information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "RequestInfoConfiguration_transferDelay_us_get", _wrap_RequestInfoConfiguration_transferDelay_us_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the transfer delay(us) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"Notes: \n"
		"- This feature currently is only available for **mvBlueFOX** devices\n"
		""},
	 { "RequestInfoConfiguration_imageAverage_get", _wrap_RequestInfoConfiguration_imageAverage_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the image average information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"Notes: \n"
		"- This feature currently is only available for **mvBlueFOX** devices\n"
		""},
	 { "RequestInfoConfiguration_IOStatesAtExposureStart_get", _wrap_RequestInfoConfiguration_IOStatesAtExposureStart_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the I/O states at exposure start information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"Notes: \n"
		"This feature currently is only available for **mvBlueFOX-MLC** devices.\n"
		""},
	 { "RequestInfoConfiguration_triggerCounterAcquisitionStart_get", _wrap_RequestInfoConfiguration_triggerCounterAcquisitionStart_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the trigger counter at acquisition start information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"Notes: \n"
		"- This feature currently is only available for **mvHYPERION** devices\n"
		""},
	 { "RequestInfoConfiguration_triggerCounterFrameStart_get", _wrap_RequestInfoConfiguration_triggerCounterFrameStart_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the trigger counter at frame start information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"Notes: \n"
		"- This feature currently is only available for **mvHYPERION** devices\n"
		""},
	 { "RequestInfoConfiguration_lineCounter_get", _wrap_RequestInfoConfiguration_lineCounter_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the line counter information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"Notes: \n"
		"- This feature currently is only available for **mvTITAN-CL**, **mvGAMMA-CL** and **mvTITAN-DIG** devices\n"
		""},
	 { "RequestInfoConfiguration_userData_get", _wrap_RequestInfoConfiguration_userData_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the user data information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"Notes: \n"
		"This feature currently is only available for **mvVirtual** devices.\n"
		""},
	 { "RequestInfoConfiguration_lineStatusAll_get", _wrap_RequestInfoConfiguration_lineStatusAll_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure whether the line status all information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"Notes: \n"
		"- This feature may be available for GenICam compliant devices\n"
		""},
	 { "delete_RequestInfoConfiguration", _wrap_delete_RequestInfoConfiguration, METH_O, NULL},
	 { "RequestInfoConfiguration_swigregister", RequestInfoConfiguration_swigregister, METH_O, NULL},
	 { "RequestInfoConfiguration_swiginit", RequestInfoConfiguration_swiginit, METH_VARARGS, NULL},
	 { "WhiteBalanceSettings_WBAoiMode_get", _wrap_WhiteBalanceSettings_WBAoiMode_get, METH_O, "\n"
		"An enumerated integer property defining the which area of the image is used for the calculation of the parameters.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAoiMode**.\n"
		""},
	 { "WhiteBalanceSettings_aoiHeight_get", _wrap_WhiteBalanceSettings_aoiHeight_get, METH_O, "\n"
		"An integer property defining the height of the AOI in pixel to be used for the calculation.\n"
		"Notes: \n"
		"This property will be visible only when **mvIMPACT::acquire::WhiteBalanceSettings::WBAoiMode**\n"
		"is set to **mvIMPACT::acquire::amUseAoi**.\n"
		""},
	 { "WhiteBalanceSettings_aoiStartX_get", _wrap_WhiteBalanceSettings_aoiStartX_get, METH_O, "\n"
		"An integer property defining the X-offset of the AOI in pixel to be used for the calculation.\n"
		"Notes: \n"
		"This property will be visible only when **mvIMPACT::acquire::WhiteBalanceSettings::WBAoiMode**\n"
		"is set to **mvIMPACT::acquire::amUseAoi**.\n"
		""},
	 { "WhiteBalanceSettings_aoiStartY_get", _wrap_WhiteBalanceSettings_aoiStartY_get, METH_O, "\n"
		"An integer property defining the Y-offset of the AOI in pixel to be used for the calculation.\n"
		"Notes: \n"
		"This property will be visible only when **mvIMPACT::acquire::WhiteBalanceSettings::WBAoiMode**\n"
		"is set to **mvIMPACT::acquire::amUseAoi**.\n"
		""},
	 { "WhiteBalanceSettings_aoiWidth_get", _wrap_WhiteBalanceSettings_aoiWidth_get, METH_O, "\n"
		"An integer property defining the width of the AOI in pixel to be used for the calculation.\n"
		"Notes: \n"
		"This property will be visible only when **mvIMPACT::acquire::WhiteBalanceSettings::WBAoiMode**\n"
		"is set to **mvIMPACT::acquire::amUseAoi**.\n"
		""},
	 { "WhiteBalanceSettings_totalGain_get", _wrap_WhiteBalanceSettings_totalGain_get, METH_O, " A float property defining the overall gain."},
	 { "WhiteBalanceSettings_redGain_get", _wrap_WhiteBalanceSettings_redGain_get, METH_O, " A float property defining the gain for the red channel."},
	 { "WhiteBalanceSettings_greenGain_get", _wrap_WhiteBalanceSettings_greenGain_get, METH_O, " A float property defining the gain for the green channel."},
	 { "WhiteBalanceSettings_blueGain_get", _wrap_WhiteBalanceSettings_blueGain_get, METH_O, " A float property defining the gain for the blue channel."},
	 { "WhiteBalanceSettings_WBResult_get", _wrap_WhiteBalanceSettings_WBResult_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** containing the result of the last white balance calibration.\n"
		"After the **mvIMPACT::acquire::Device** has been initialized, the value of this property will be\n"
		"**mvIMPACT::acquire::bwbrUnknown**.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerWhiteBalanceResult**.\n"
		""},
	 { "delete_WhiteBalanceSettings", _wrap_delete_WhiteBalanceSettings, METH_O, NULL},
	 { "WhiteBalanceSettings_swigregister", WhiteBalanceSettings_swigregister, METH_O, NULL},
	 { "GainOffsetKneeChannelParameters_gain_get", _wrap_GainOffsetKneeChannelParameters_gain_get, METH_O, "\n"
		"A float property that contains the channel specific gain to be applied to the selected channel of the image.\n"
		"This gain will be applied after the master offset but before the channel specific offset.\n"
		""},
	 { "GainOffsetKneeChannelParameters_offset_pc_get", _wrap_GainOffsetKneeChannelParameters_offset_pc_get, METH_O, "\n"
		"A float property that contains the channel specific offset (in percent) to be applied to the selected channel of the image.\n"
		"This offset will be applied after the channel specific gain.\n"
		""},
	 { "delete_GainOffsetKneeChannelParameters", _wrap_delete_GainOffsetKneeChannelParameters, METH_O, NULL},
	 { "GainOffsetKneeChannelParameters_swigregister", GainOffsetKneeChannelParameters_swigregister, METH_O, NULL},
	 { "LUTParameters_gamma_get", _wrap_LUTParameters_gamma_get, METH_O, "\n"
		" A float property which can be used to set the gamma value.\n"
		" Gamma correction is explained e.g. in this Wikipedia article: http://en.wikipedia.org/wiki/Gamma_correction.\n"
		"\n"
		" Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		" **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		" **mvIMPACT::acquire::LUTmGamma**.\n"
		"\n"
		" The gamma value will be used to calculate the corresponding input -> output transformation LUT.\n"
		"\n"
		" The following formula will be used:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"      ( ( 1 + gammaAlpha ) * inputValue^(1/gamma) ) - gammaAlpha\n"
		""},
	 { "LUTParameters_gammaAlpha_get", _wrap_LUTParameters_gammaAlpha_get, METH_O, "\n"
		"A float property which can be used to set the gammaAlpha value.\n"
		"Refer to **mvIMPACT::acquire::LUTParameters::gamma** to see how this parameter affects the resulting\n"
		"LUT data.\n"
		"\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTmGamma**.\n"
		""},
	 { "LUTParameters_gammaMode_get", _wrap_LUTParameters_gammaMode_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure the LUT(**L**ook **U**p **T**able) gamma mode.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTGammaMode**.\n"
		"\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTmGamma**.\n"
		""},
	 { "LUTParameters_gammaStartThreshold_get", _wrap_LUTParameters_gammaStartThreshold_get, METH_O, "\n"
		"An integer property which can be used to define a start threshold above which the gamma correction formula shall be used in **mvIMPACT::acquire::LUTParameters::gammaMode** **mvIMPACT::acquire::LUTgmLinearStart**.\n"
		"Values below that threshold will be calculated using linear interpolation.\n"
		"\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTmGamma** or if **mvIMPACT::acquire::LUTParameters::gammaMode** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTgmLinearStart**.\n"
		""},
	 { "LUTParameters_gammaInverter_get", _wrap_LUTParameters_gammaInverter_get, METH_O, "\n"
		"An enumerated integer property defining whether the calculated gamma correction function shall be inverted or not\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTmGamma**.\n"
		"\n"
		"This property is mainly provided for compatibility reasons since the original implementation of\n"
		"the mvIMPACT Acquire framework and the implementation inside MATRIX VISION GmbH GenICam devices introduced later\n"
		"differ. The default behaviour of the mvIMPACT Acquire results in the reverse function of the gamma function\n"
		"inside the device firmware thus the gamma value specified here results in the same response as if applying\n"
		"(1/gamma value) to a device. So a gamma value of 2.2 with the inverter switched off this would result in the same\n"
		"response as a gamma value of 0.45 with the inverter switched on. In order not to change the default behaviour of this filter\n"
		"the default value for this property will be **mvIMPACT::acquire::bTrue** and can be set to\n"
		"**mvIMPACT::acquire::bFalse** to achieve the same behaviour as implemented for GenICam devices and specified in\n"
		"the SFNC (GenICam Standard Features Naming Convention).\n"
		"\n"
		"Since: 2.38.0\n"
		""},
	 { "LUTParameters_valueCount_get", _wrap_LUTParameters_valueCount_get, METH_O, "\n"
		" An integer property to define the number of sampling points for interpolated LUT transformations.\n"
		" Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		" **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		" **mvIMPACT::acquire::LUTmInterpolated**.\n"
		"\n"
		" At least 2 sampling points are needed, the max. number of sampling points is defined by the bit depth of the input\n"
		" image, thus a 8 bit input image can have no more than 2^8 (256) sampling points. if the max. number of sampling points\n"
		" is used, the behaviour is the same a when working with **mvIMPACT::acquire::ImageProcessing::LUTMode** set to\n"
		" **mvIMPACT::acquire::LUTmDirect**.\n"
		"\n"
		" **EXAMPLE**\n"
		"\n"
		" Assuming 4 sampling points in **mvIMPACT::acquire::LUTimThreshold** mode for an 8 to 8 bit transformation where the following\n"
		" values are used:\n"
		"\n"
		"\n"
		" -----------------------\n"
		" |index|input value|output value|\n"
		" |0|0|64|\n"
		" |1|128|255|\n"
		" |2|192|0|\n"
		" |3|255|0|\n"
		"\n"
		"\n"
		" This will result in the following transfer function characteristic:\n"
		"\n"
		" Image: LUT_ThresholdInterpolation_4SamplingPoints.png\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" **The** following C++ code would be needed to achieve this behaviour for mono video sources:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     //-----------------------------------------------------------------------------\n"
		"     void fn( ImageProcessing ip, TLUTImplemention LUTImplementation )\n"
		"     //-----------------------------------------------------------------------------\n"
		"     {\n"
		"       ip.LUTEnable.write( bTrue );\n"
		"       ip.LUTMode.write( LUTmInterpolated );\n"
		"       ip.LUTImplementation.write( LUTImplementation );\n"
		"       ip.LUTInterpolationMode.write( LUTimThreshold );\n"
		"       switch( LUTImplementation )\n"
		"       {\n"
		"         case LUTiHardware:\n"
		"           ip.LUTMappingHardware.write( LUTm8To8 );\n"
		"           break;\n"
		"         case LUTiSoftware:\n"
		"           ip.LUTMappingSoftware.write( LUTm8To8 );\n"
		"           break;\n"
		"        }\n"
		"        LUTParameters LUTAccess = ip.getLUTParameter( 0 );\n"
		"        LUTAccess.valueCount.write( 4 );\n"
		"        vectorint v(4);\n"
		"        v[0] = 0;\n"
		"        v[1] = 128;\n"
		"        v[2] = 192;\n"
		"        v[3] = 255;\n"
		"        LUTAccess.inputValues.write( v );\n"
		"        v[0] = 64;\n"
		"        v[1] = 255;\n"
		"        v[2] = 0;\n"
		"        v[3] = 0;\n"
		"        LUTAccess.outputValues.write( v );\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     //-----------------------------------------------------------------------------\n"
		"     public void fn( ImageProcessing ip, final int LUTImplementation )\n"
		"     //-----------------------------------------------------------------------------\n"
		"     {\n"
		"       ip.getLUTEnable().write( TBoolean.bTrue );\n"
		"       ip.getLUTMode().write( TLUTMode.LUTmInterpolated );\n"
		"       ip.getLUTImplementation().write( LUTImplementation );\n"
		"       ip.getLUTInterpolationMode().write( TLUTInterpolationMode.LUTimThreshold );\n"
		"       if( LUTImplementation == TLUTImplementation.LUTiHardware )\n"
		"       {\n"
		"         ip.getLUTMappingHardware().write( TLUTMapping.LUTm8To8 );\n"
		"       }\n"
		"       else if( LUTImplementation == TLUTImplementation.LUTiSoftware )\n"
		"       {\n"
		"         ip.getLUTMappingSoftware().write( TLUTMapping.LUTm8To8 );\n"
		"       }\n"
		"       LUTParameters LUTAccess = ip.getLUTParameter( 0 );\n"
		"       LUTAccess.getValueCount().write( 4 );\n"
		"       {\n"
		"         IntVector v = new IntVector();\n"
		"         v.add( 0 );\n"
		"         v.add( 128 );\n"
		"         v.add( 192 );\n"
		"         v.add( 255 );\n"
		"         LUTAccess.getInputValues().write( v );\n"
		"       }\n"
		"       {\n"
		"         IntVector v = new IntVector();\n"
		"         v.add( 64 );\n"
		"         v.add( 255 );\n"
		"         v.add( 0 );\n"
		"         v.add( 0 );\n"
		"         LUTAccess.getOutputValues().write( v );\n"
		"       }\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     This sample assumes a valid reference to a mvIMPACT::acquire::ImageProcessing object has been obtained.\n"
		"     def fn(ip, LUTImplementation):\n"
		"       ip.LUTEnable.write(acquire.bTrue)\n"
		"       ip.LUTMode.write(acquire.LUTmInterpolated)\n"
		"       ip.LUTImplementation.write(LUTImplementation)\n"
		"       ip.LUTInterpolationMode.write(LUTimThreshold)\n"
		"       if LUTImplementation == LUTiHardware:\n"
		"           ip.LUTMappingHardware.write(acquire.LUTm8To8)\n"
		"       elif LUTImplementation == LUTiSoftware:\n"
		"           ip.LUTMappingSoftware.write(acquire.LUTm8To8)\n"
		"\n"
		"       LUTAccess = ip.getLUTParameter(0)\n"
		"       LUTAccess.valueCount.write(4)\n"
		"       v = []\n"
		"       v[0] = 0\n"
		"       v[1] = 128\n"
		"       v[2] = 192\n"
		"       v[3] = 255\n"
		"       LUTAccess.inputValues.write(v)\n"
		"\n"
		"       v[0] = 64\n"
		"       v[1] = 255\n"
		"       v[2] = 0\n"
		"       v[3] = 0\n"
		"       LUTAccess.outputValues.write(v)\n"
		"}\n"
		" Assuming 3 sampling points in **mvIMPACT::acquire::LUTimLinear** mode for an 8 to 8 bit transformation where the following\n"
		" values are used:\n"
		"\n"
		"\n"
		" |index|input value|output value|\n"
		" |0|0|64|\n"
		" |1|128|255|\n"
		" |2|255|0|\n"
		"\n"
		"\n"
		" This will result in the following transfer function characteristic:\n"
		"\n"
		" Image: LUT_linearInterpolation_3SamplingPoints.png\n"
		"\n"
		" Assuming 4 sampling points in **mvIMPACT::acquire::LUTimCubic** mode for an 8 to 8 bit transformation where the following\n"
		" values are used:\n"
		"\n"
		"\n"
		" |index|input value|output value|\n"
		" |0|0|0|\n"
		" |1|128|255|\n"
		" |2|192|192|\n"
		" |3|255|0|\n"
		"\n"
		"\n"
		" This will result in the following transfer function characteristic:\n"
		"\n"
		" Image: LUT_CubicInterpolation_4SamplingPoints.png\n"
		""},
	 { "LUTParameters_inputValues_get", _wrap_LUTParameters_inputValues_get, METH_O, "\n"
		"An integer property to define the input values for sampling points for interpolated LUT transformations.\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTmInterpolated**.\n"
		"\n"
		"The number of values stored by this property can be changed by writing to the property **mvIMPACT::acquire::LUTParameters::valueCount**.\n"
		"The documentation of this property also provides some example values and resulting transfer characteristics.\n"
		""},
	 { "LUTParameters_outputValues_get", _wrap_LUTParameters_outputValues_get, METH_O, "\n"
		"An integer property to define the output values for sampling points for interpolated LUT transformations.\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTmInterpolated**.\n"
		"\n"
		"The number of values stored by this property can be changed by writing to the property **mvIMPACT::acquire::LUTParameters::valueCount**.\n"
		"The documentation of this property also provides some example values and resulting transfer characteristics.\n"
		""},
	 { "LUTParameters_directValues_get", _wrap_LUTParameters_directValues_get, METH_O, "\n"
		"An integer property which can be used to directly define a LUT.\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTmDirect**.\n"
		"\n"
		"This property will provide a complete LUT thus e.g. in a LUT mapping to a 10 bit output this property will store 2^10 (1024)\n"
		"values that can be accessed and modified by the user.\n"
		""},
	 { "delete_LUTParameters", _wrap_delete_LUTParameters, METH_O, NULL},
	 { "LUTParameters_swigregister", LUTParameters_swigregister, METH_O, NULL},
	 { "MirrorParameters_mirrorMode_get", _wrap_MirrorParameters_mirrorMode_get, METH_O, "\n"
		"An enumerated integer property defining the mirror mode to be applied to this channel of the image.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMirrorMode**.\n"
		""},
	 { "delete_MirrorParameters", _wrap_delete_MirrorParameters, METH_O, NULL},
	 { "MirrorParameters_swigregister", MirrorParameters_swigregister, METH_O, NULL},
	 { "new_ImageProcessing", _wrap_new_ImageProcessing, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new **mvIMPACT::acquire::ImageProcessing** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::ImageProcessing** from an existing one.\n"
		":type src: :py:class:`ImageProcessing`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::ImageProcessing** object, this object shall be created from\n"
		""},
	 { "delete_ImageProcessing", _wrap_delete_ImageProcessing, METH_O, " Class destructor."},
	 { "ImageProcessing_colorProcessing_get", _wrap_ImageProcessing_colorProcessing_get, METH_O, "\n"
		"An enumerated integer property defining what kind of color processing shall be applied to the raw image data.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TColorProcessingMode**.\n"
		""},
	 { "ImageProcessing_bayerConversionMode_get", _wrap_ImageProcessing_bayerConversionMode_get, METH_O, "\n"
		"An enumerated integer property defining what kind of algorithm shall be used during Bayer to RGB conversion.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerConversionMode**.\n"
		""},
	 { "ImageProcessing_adaptiveEdgeSensingPlusSharpenThreshold_get", _wrap_ImageProcessing_adaptiveEdgeSensingPlusSharpenThreshold_get, METH_O, "\n"
		"An integer property defining the max. brightness level difference for which sharpening is not applied during AdaptiveEdgeSensingPlus deBayering.\n"
		"Valid values for this property are between 0 and 2^(bits per pixel).\n"
		"\n"
		"Since: 2.26.0\n"
		""},
	 { "ImageProcessing_adaptiveEdgeSensingPlusSharpenGain_get", _wrap_ImageProcessing_adaptiveEdgeSensingPlusSharpenGain_get, METH_O, "\n"
		"A floating point property defining the intensity of the sharpening during AdaptiveEdgeSensingPlus deBayering.\n"
		"Valid values for this property are between 0. and 100. (percent).\n"
		"\n"
		"Since: 2.26.0\n"
		""},
	 { "ImageProcessing_whiteBalance_get", _wrap_ImageProcessing_whiteBalance_get, METH_O, "\n"
		"An integer property defining the parameter set to be used to perform the white balance correction.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TWhiteBalanceParameter**.\n"
		""},
	 { "ImageProcessing_whiteBalanceCalibration_get", _wrap_ImageProcessing_whiteBalanceCalibration_get, METH_O, "\n"
		"An enumerated integer property defining the mode used for white balance calibration.\n"
		"This property can be used to define the way a white balance calibration shall be performed.\n"
		"Currently only the **mvIMPACT::acquire::wbcmNextFrame** mode is supported,\n"
		"but new modes might appear in later revisions of the interface.\n"
		"\n"
		"When this property is set to **mvIMPACT::acquire::wbcmNextFrame** the next\n"
		"image captured will be used as a reference to calculate the gain factors for the\n"
		"*red*, *green* and *blue* channel. So make sure when the next image is captured the camera\n"
		"looks on a plain white or slightly grey surface in order to obtain correct results. After\n"
		"the calibration has been done, the property will be reset to **mvIMPACT::acquire::wbcmOff**\n"
		"again.\n"
		"\n"
		"Notes: \n"
		"Performing this kind of white balance calibration will only affect Bayer color sensors and will\n"
		"only have any visual effect on the image if one of the user definable parameter sets has been\n"
		"selected before. This can be done by modifying the property **mvIMPACT::acquire::ImageProcessing::whiteBalance**.\n"
		"Afterwards the calculated factors will be stored in the **mvIMPACT::acquire::WhiteBalanceSettings** selected.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TWhiteBalanceCalibrationMode**.\n"
		""},
	 { "ImageProcessing_filter_get", _wrap_ImageProcessing_filter_get, METH_O, "\n"
		"An enumerated integer property defining the filter to be applied to the image before it is transferred to the user.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageProcessingFilter**.\n"
		""},
	 { "ImageProcessing_mirrorOperationMode_get", _wrap_ImageProcessing_mirrorOperationMode_get, METH_O, "\n"
		"An enumerated integer property defining the general mode the mirror filter will work in.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMirrorOperationMode**.\n"
		""},
	 { "ImageProcessing_mirrorModeGlobal_get", _wrap_ImageProcessing_mirrorModeGlobal_get, METH_O, "\n"
		"An enumerated integer property defining the mirror mode to be applied to ALL channels of the image.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMirrorMode**.\n"
		"\n"
		"Notes: This property will only be visible, when **mvIMPACT::acquire::ImageProcessing::mirrorOperationMode** is set\n"
		"to **mvIMPACT::acquire::momGlobal**.\n"
		""},
	 { "ImageProcessing_polarizedDataExtractionEnable_get", _wrap_ImageProcessing_polarizedDataExtractionEnable_get, METH_O, "\n"
		"An enumerated integer property defining whether the polarization data extraction filter shall be active or not.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Since: 2.29.0\n"
		""},
	 { "ImageProcessing_polarizedDataExtractionMode_get", _wrap_ImageProcessing_polarizedDataExtractionMode_get, METH_O, "\n"
		"An enumerated integer property defining in which mode the polarization data extraction filter shall be operated in.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TPolarizedDataExtractionMode**.\n"
		"\n"
		"Since: 2.29.0\n"
		""},
	 { "ImageProcessing_polarizedDataExtractionInterpolationMode_get", _wrap_ImageProcessing_polarizedDataExtractionInterpolationMode_get, METH_O, "\n"
		"An enumerated integer property defining the interpolation mode the polarization data extraction filter shall be operated in.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode**.\n"
		"\n"
		"Notes: This property will only be available when the polarization data extraction mode is either horizontal, vertical or single.\n"
		"\n"
		"Since: 2.29.0\n"
		""},
	 { "ImageProcessing_polarizedDataExtractionChannelIndex_get", _wrap_ImageProcessing_polarizedDataExtractionChannelIndex_get, METH_O, "\n"
		"An integer property defining the channel within the processing window of the polarization data extraction filter.\n"
		"This channel will only be taken into account when **mvIMPACT::acquire::ImageProcessing::polarizedDataExtractionMode** is set to\n"
		"**mvIMPACT::acquire::prmExtractSingle**.\n"
		"\n"
		"Since: 2.29.0\n"
		""},
	 { "ImageProcessing_polarizedDataExtractionLowerLimit_get", _wrap_ImageProcessing_polarizedDataExtractionLowerLimit_get, METH_O, "\n"
		"An integer property defining the lower limit of the grey value of a pixel to be taken into account within the processing window of the polarization data extraction filter.\n"
		"This limit will only be taken into account when **mvIMPACT::acquire::ImageProcessing::polarizedDataExtractionMode** is set to\n"
		"**mvIMPACT::acquire::prmMeanValue**.\n"
		"\n"
		"Since: 2.29.0\n"
		""},
	 { "ImageProcessing_polarizedDataExtractionUpperLimit_get", _wrap_ImageProcessing_polarizedDataExtractionUpperLimit_get, METH_O, "\n"
		"An integer property defining the upper limit of the grey value of a pixel to be taken into account within the processing window of the polarization data extraction filter.\n"
		"This limit will only be taken into account when **mvIMPACT::acquire::ImageProcessing::polarizedDataExtractionMode** is set to\n"
		"**mvIMPACT::acquire::prmMeanValue**.\n"
		"\n"
		"Since: 2.29.0\n"
		""},
	 { "ImageProcessing_defectivePixelsFilterMode_get", _wrap_ImageProcessing_defectivePixelsFilterMode_get, METH_O, "\n"
		"An enumerated integer property defining the operation mode of the defective pixels filter.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDefectivePixelsFilterMode**.\n"
		""},
	 { "ImageProcessing_defectivePixelsFilterLeakyPixelDeviation_ADCLimit_get", _wrap_ImageProcessing_defectivePixelsFilterLeakyPixelDeviation_ADCLimit_get, METH_O, "\n"
		"An integer property defining the max. allowed offset from the average grey value for a pixel during calibration.\n"
		"When this filter is calibrated each pixel producing a grey value higher than the average grey value plus\n"
		"the value of this property will be considered as a leaky pixel and therefore will be replaced by\n"
		"a value depending on the operation mode of the filter.\n"
		""},
	 { "ImageProcessing_defectivePixelsFilterColdPixelDeviation_pc_get", _wrap_ImageProcessing_defectivePixelsFilterColdPixelDeviation_pc_get, METH_O, "\n"
		"An integer property defining the max. allowed deviation for a pixel in per cent from the average grey value.\n"
		"If this filter is active every pixel that during the calibration produces a grey value which is\n"
		"lower than the average grey value of the image minus the allowed deviation in per cent will be\n"
		"considered as a cold pixel and therefore will be replaced by a value depending on the operation\n"
		"mode of the filter.\n"
		""},
	 { "ImageProcessing_defectivePixelsMaxDetectionCount_get", _wrap_ImageProcessing_defectivePixelsMaxDetectionCount_get, METH_O, "\n"
		"An integer property defining maximum the number of pixels considered as being defective during consecutive calibration runs.\n"
		"With this property it is possible to define an upper limit for the number of detected defective pixels. This is not to be meant\n"
		"as an error checking mechanism for sensors reporting more defective pixels but to allow an application to keep the length of the\n"
		"list of defective pixels within reasonable boundaries. The more pixels a sensor has the higher a reasonable value might be. Set this\n"
		"to a value suitable for your application to protect the algorithm from huge lists due to incorrect calibration environments (too much light,\n"
		"not enough light, ...).\n"
		"\n"
		"When after a calibration this value and the value of the **mvIMPACT::acquire::ImageProcessing::defectivePixelsFound** property are the\n"
		"same this indicates a problem. There are several possible reasons for this:\n"
		"\n"
		"- the lighting conditions or calibration parameters have not been set up correctly (fix your setup then)\n"
		"- the sensor is damaged (replace the device then)\n"
		"- the sensor has more defective pixels then indicated by the value of this property but which are still valid according to the specification of the sensor manufacturer (adjust the value of this property accordingly then)\n"
		"\n"
		"When reducing this value at runtime excess pixels will be dropped from the current list of defective pixels if the new maximum list length is smaller than the amount of\n"
		"defective pixels currently detected.\n"
		"\n"
		"Some devices might offer to store defective pixels inside the device in an mvIMPACT Acquire compatible format by calling **mvIMPACT::acquire::ImageProcessing::defectivePixelWriteToDevice**.\n"
		"However the device might not be able to store all these pixels due to a lack of storage space. Therefore always check the return value of the function!\n"
		"\n"
		"Notes: \n"
		"In order to get rid of currently detected pixels an application must set the property\n"
		"**mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**\n"
		"and then capture a fresh image. Only then all currently detected pixels will be discarded.\n"
		"\n"
		"Since: 2.37.0\n"
		""},
	 { "ImageProcessing_defectivePixelsFound_get", _wrap_ImageProcessing_defectivePixelsFound_get, METH_O, "\n"
		"An integer property **(read-only)** containing the number of pixels considered as being defective with respect to the calibration runs executed after the last reset of the calibration data.\n"
		"Notes: \n"
		"In order to collect **ALL** defective pixels the list of detected pixels is not emptied each time a new calibration\n"
		"is started. In order to get rid of currently detected pixels an application must set the property\n"
		"**mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**\n"
		"and then capture a fresh image. Only then all currently detected pixels will be discarded.\n"
		"\n"
		"Since: 2.5.9\n"
		""},
	 { "ImageProcessing_defectivePixelOffsetX_get", _wrap_ImageProcessing_defectivePixelOffsetX_get, METH_O, "\n"
		"An integer property defining a list of X-offsets of all pixels currently treated as defective.\n"
		"All these pixels will be replaced depending on the selected algorithm in **mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode**.\n"
		"\n"
		"Notes: \n"
		"In order to collect **ALL** defective pixels the list of detected pixels is not emptied each time a new calibration\n"
		"is started. In order to get rid of currently detected pixels an application must set the property\n"
		"**mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**\n"
		"and then capture a fresh image. Only then all currently detected pixels will be discarded.\n"
		"\n"
		"Since: 2.17.1\n"
		""},
	 { "ImageProcessing_defectivePixelOffsetY_get", _wrap_ImageProcessing_defectivePixelOffsetY_get, METH_O, "\n"
		"An integer property defining a list of Y-offsets of all pixels currently treated as defective.\n"
		"All these pixels will be replaced depending on the selected algorithm in **mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode**.\n"
		"\n"
		"Notes: \n"
		"In order to collect **ALL** defective pixels the list of detected pixels is not emptied each time a new calibration\n"
		"is started. In order to get rid of currently detected pixels an application must set the property\n"
		"**mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**\n"
		"and then capture a fresh image. Only then all currently detected pixels will be discarded.\n"
		"\n"
		"Since: 2.17.1\n"
		""},
	 { "ImageProcessing_defectivePixelReadFromDevice_get", _wrap_ImageProcessing_defectivePixelReadFromDevice_get, METH_O, "\n"
		"Calling this method will download defective pixels from the device.\n"
		"Notes: \n"
		"In order to collect **ALL** defective pixels the list of detected pixels is not emptied each time a download from the device is executed.\n"
		"In order to get rid of currently detected pixels an application must set the property\n"
		"**mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**\n"
		"and then capture a fresh image. Only then all currently detected pixels will be discarded.\n"
		"\n"
		"\n"
		"This feature will only be supported by some devices providing a special interface inside their firmware.\n"
		"\n"
		"Since: 2.17.1\n"
		"\n"
		"Calling this method will return\n"
		"\n"
		"- **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"- A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise. Most likely mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE if the device does not support this feature.\n"
		""},
	 { "ImageProcessing_defectivePixelWriteToDevice_get", _wrap_ImageProcessing_defectivePixelWriteToDevice_get, METH_O, "\n"
		"Calling this method will upload defective pixels from the device.\n"
		"Notes: \n"
		"This will **NOT** automatically store this data in non-volatile memory on the device!\n"
		"A call to **mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl::mvDefectivePixelDataSave** might be needed!\n"
		"\n"
		"\n"
		"This feature will only be supported by some devices providing a special interface inside their firmware.\n"
		"\n"
		"Since: 2.17.1\n"
		"\n"
		"Calling this method will return\n"
		"\n"
		"- **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"- A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise. Most likely mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE if the device does not support this feature.\n"
		""},
	 { "ImageProcessing_flatFieldFilterMode_get", _wrap_ImageProcessing_flatFieldFilterMode_get, METH_O, "\n"
		"An enumerated integer property defining the operation mode of the flat field correction filter.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TFlatFieldFilterMode**.\n"
		""},
	 { "ImageProcessing_flatFieldFilterCorrectionMode_get", _wrap_ImageProcessing_flatFieldFilterCorrectionMode_get, METH_O, "\n"
		"An enumerated integer property defining the correction mode of the flat field correction filter.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TFlatFieldFilterCorrectionMode**.\n"
		""},
	 { "ImageProcessing_flatFieldFilterCorrectionModeReverseX_get", _wrap_ImageProcessing_flatFieldFilterCorrectionModeReverseX_get, METH_O, "\n"
		"An enumerated integer property defining the X-orientation that shall be used when applying the correction.\n"
		"When active the calibration image will be applied reversed X direction thus the last correction factor of each line of the correction image will be applied to the first pixel of the image etc.. This can be useful e.g. if the calibration has been done and the device shall transmit the image flipped on a vertical axis in some configurations.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Since: 2.40.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCorrectionModeReverseY_get", _wrap_ImageProcessing_flatFieldFilterCorrectionModeReverseY_get, METH_O, "\n"
		"An enumerated integer property defining the Y-orientation that shall be used when applying the correction.\n"
		"When active the calibration image will be applied reversed Y direction thus the last line of correction factors of the correction image will be applied to the first line of the image etc.. This can be useful e.g. if the calibration has been done and the device shall transmit the image flipped on a horizontal axis in some configurations.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Since: 2.40.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCorrectionAoiMode_get", _wrap_ImageProcessing_flatFieldFilterCorrectionAoiMode_get, METH_O, "\n"
		"An enumerated integer property defining the correction AOI mode of the flat field correction filter.\n"
		"When using an AOI only the AOI region is corrected by this filter.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAoiMode**.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCorrectionAoiOffsetX_get", _wrap_ImageProcessing_flatFieldFilterCorrectionAoiOffsetX_get, METH_O, "\n"
		"An integer property defining the correction AOI's X-offset of the flat field correction filter.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCorrectionAoiOffsetY_get", _wrap_ImageProcessing_flatFieldFilterCorrectionAoiOffsetY_get, METH_O, "\n"
		"An integer property defining the correction AOI's Y-offset of the flat field correction filter.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCorrectionAoiWidth_get", _wrap_ImageProcessing_flatFieldFilterCorrectionAoiWidth_get, METH_O, "\n"
		"An integer property defining the correction AOI's width of the flat field correction filter.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCorrectionAoiHeight_get", _wrap_ImageProcessing_flatFieldFilterCorrectionAoiHeight_get, METH_O, "\n"
		"An integer property defining the correction AOI's height of the flat field correction filter.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCalibrationImageCount_get", _wrap_ImageProcessing_flatFieldFilterCalibrationImageCount_get, METH_O, " An integer property defining the number of consecutive images to take into account during the calibration of the flat field filter."},
	 { "ImageProcessing_flatFieldFilterCalibrationAoiMode_get", _wrap_ImageProcessing_flatFieldFilterCalibrationAoiMode_get, METH_O, "\n"
		"An enumerated integer property defining the correction AOI mode of the flat field correction filter.\n"
		"When using an AOI only the AOI region is taken into consideration during calibration by this filter.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAoiMode**.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCalibrationAoiOffsetX_get", _wrap_ImageProcessing_flatFieldFilterCalibrationAoiOffsetX_get, METH_O, "\n"
		"An integer property defining the calibration AOI's X-offset of the flat field correction filter.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCalibrationAoiOffsetY_get", _wrap_ImageProcessing_flatFieldFilterCalibrationAoiOffsetY_get, METH_O, "\n"
		"An integer property defining the calibration AOI's Y-offset of the flat field correction filter.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCalibrationAoiWidth_get", _wrap_ImageProcessing_flatFieldFilterCalibrationAoiWidth_get, METH_O, "\n"
		"An integer property defining the calibration AOI's width of the flat field correction filter.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_flatFieldFilterCalibrationAoiHeight_get", _wrap_ImageProcessing_flatFieldFilterCalibrationAoiHeight_get, METH_O, "\n"
		"An integer property defining the calibration AOI's height of the flat field correction filter.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_darkCurrentFilterMode_get", _wrap_ImageProcessing_darkCurrentFilterMode_get, METH_O, "\n"
		"An enumerated integer property defining the operation mode of the dark current filter.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDarkCurrentFilterMode**.\n"
		""},
	 { "ImageProcessing_darkCurrentFilterCalibrationImageCount_get", _wrap_ImageProcessing_darkCurrentFilterCalibrationImageCount_get, METH_O, " An integer property defining the number of consecutive images to take into account during calibration of the dark current filter."},
	 { "ImageProcessing_gainOffsetKneeEnable_get", _wrap_ImageProcessing_gainOffsetKneeEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable the Gain, Offset, Knee filter.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "ImageProcessing_gainOffsetKneeMasterOffset_pc_get", _wrap_ImageProcessing_gainOffsetKneeMasterOffset_pc_get, METH_O, "\n"
		"A float property that contains master offset(in percent).\n"
		"This offset will be applied before the channel specific gain.\n"
		""},
	 { "ImageProcessing_LUTEnable_get", _wrap_ImageProcessing_LUTEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable LUT (**L**ook **U**p **T**able) transformations.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "ImageProcessing_LUTMode_get", _wrap_ImageProcessing_LUTMode_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) transformation mode.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTMode**.\n"
		"\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse**.\n"
		""},
	 { "ImageProcessing_LUTInterpolationMode_get", _wrap_ImageProcessing_LUTInterpolationMode_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) interpolation mode.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTInterpolationMode**.\n"
		"\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTmInterpolated**.\n"
		""},
	 { "ImageProcessing_LUTImplementation_get", _wrap_ImageProcessing_LUTImplementation_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) implementation.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTImplementation**.\n"
		"\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse**.\n"
		""},
	 { "ImageProcessing_LUTMappingHardware_get", _wrap_ImageProcessing_LUTMappingHardware_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) mapping mode for LUT transformations done by the hardware.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTMapping**.\n"
		"\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTImplementation** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTiHardware**.\n"
		""},
	 { "ImageProcessing_LUTMappingSoftware_get", _wrap_ImageProcessing_LUTMappingSoftware_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) mapping mode for LUT transformations done optimized software algorithms.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTMapping**.\n"
		"\n"
		"Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to\n"
		"**mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTImplementation** is **NOT** set to\n"
		"**mvIMPACT::acquire::LUTiSoftware**.\n"
		""},
	 { "ImageProcessing_tapSortEnable_get", _wrap_ImageProcessing_tapSortEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable/disable automatic data re-ordering from image sources delivering data from multiple taps that require re-ordering to reconstruct the image.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "ImageProcessing_channelSplitEnable_get", _wrap_ImageProcessing_channelSplitEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable/disable automatic data re-ordering or extraction from multi-channel images.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "ImageProcessing_channelSplitMode_get", _wrap_ImageProcessing_channelSplitMode_get, METH_O, "\n"
		"An enumerated integer property which can be used to define how data from multi-channel images shall be re-ordered.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TChannelSplitMode**.\n"
		""},
	 { "ImageProcessing_channelSplitChannelIndex_get", _wrap_ImageProcessing_channelSplitChannelIndex_get, METH_O, "\n"
		"An integer property which can be used to define which channel of the image shall be extracted.\n"
		"This property will only be visible if **mvIMPACT::acquire::ImageProcessing::channelSplitMode** is set\n"
		"to **mvIMPACT::acquire::csmExtractSingle**.\n"
		""},
	 { "ImageProcessing_channelSplitDeinterlaceEnable_get", _wrap_ImageProcessing_channelSplitDeinterlaceEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable/disable data re-ordering for interlaced images.\n"
		"Enabling this feature will cause interlaced images in a way that the 2 fields will be display next to each other. This\n"
		"will modify the original image in an image with twice the width but half the height.\n"
		"\n"
		"Notes: \n"
		"Right now this property will only result in correct results for images, that are line wise interlaced, thus\n"
		"some special sensors that e.g. transfer Bayer interlaced data (2 lines field 0, 2 lines field even, etc.)\n"
		"can not be re-arranged in a meaningful way.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "ImageProcessing_colorTwistInputCorrectionMatrixEnable_get", _wrap_ImageProcessing_colorTwistInputCorrectionMatrixEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable/disable the color twist input correction matrix.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistInputCorrectionMatrixMode_get", _wrap_ImageProcessing_colorTwistInputCorrectionMatrixMode_get, METH_O, "\n"
		"An enumerated integer property which can be used to select an input color correction matrix.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode**.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistInputCorrectionMatrixRow0_get", _wrap_ImageProcessing_colorTwistInputCorrectionMatrixRow0_get, METH_O, "\n"
		"The first row of the input color correction matrix.\n"
		"This property stores the first row of a user defined 3x3 input color correction matrix if\n"
		"**mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode** is set to\n"
		"**mvIMPACT::acquire::cticmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode**\n"
		"modifying this property will have no effect.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistInputCorrectionMatrixRow1_get", _wrap_ImageProcessing_colorTwistInputCorrectionMatrixRow1_get, METH_O, "\n"
		"The second row of the input color correction matrix.\n"
		"This property stores the second row of a user defined 3x3 input color correction matrix if\n"
		"**mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode** is set to\n"
		"**mvIMPACT::acquire::cticmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode**\n"
		"modifying this property will have no effect.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistInputCorrectionMatrixRow2_get", _wrap_ImageProcessing_colorTwistInputCorrectionMatrixRow2_get, METH_O, "\n"
		"The third row of the input color correction matrix.\n"
		"This property stores the third row of a user defined 3x3 input color correction matrix if\n"
		"**mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode** is set to\n"
		"**mvIMPACT::acquire::cticmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode**\n"
		"modifying this property will have no effect.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistEnable_get", _wrap_ImageProcessing_colorTwistEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable/disable the color twist matrix.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"The color twist filter can be used to apply a linear transformation to a 3 channel image. Each pixel will\n"
		"at first be multiplied by a 3x3 matrix and afterwards an offset triplet can be added.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistRow0_get", _wrap_ImageProcessing_colorTwistRow0_get, METH_O, "\n"
		"The first row of the color twist matrix.\n"
		"This property stores 4 values. The first 3 components for the first row of the 3x4 matrix, the last component is the\n"
		"offset of this row.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistRow1_get", _wrap_ImageProcessing_colorTwistRow1_get, METH_O, "\n"
		"The second row of the color twist matrix.\n"
		"This property stores 4 values. The first 3 components for the second row of the 3x4 matrix, the last component is the\n"
		"offset of this row.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistRow2_get", _wrap_ImageProcessing_colorTwistRow2_get, METH_O, "\n"
		"The third row of the color twist matrix.\n"
		"This property stores 4 values. The first 3 components for the third row of the 3x4 matrix, the last component is the\n"
		"offset of this row.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistOutputCorrectionMatrixEnable_get", _wrap_ImageProcessing_colorTwistOutputCorrectionMatrixEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable/disable the color twist output correction matrix.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistOutputCorrectionMatrixMode_get", _wrap_ImageProcessing_colorTwistOutputCorrectionMatrixMode_get, METH_O, "\n"
		"An enumerated integer property which can be used to select an output color correction matrix.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode**.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistOutputCorrectionMatrixRow0_get", _wrap_ImageProcessing_colorTwistOutputCorrectionMatrixRow0_get, METH_O, "\n"
		"The first row of the output color correction matrix.\n"
		"This property stores the first row of a user defined 3x3 output color correction matrix if\n"
		"**mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode** is set to\n"
		"**mvIMPACT::acquire::ctocmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode**\n"
		"modifying this property will have no effect.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistOutputCorrectionMatrixRow1_get", _wrap_ImageProcessing_colorTwistOutputCorrectionMatrixRow1_get, METH_O, "\n"
		"The second row of the output color correction matrix.\n"
		"This property stores the second row of a user defined 3x3 output color correction matrix if\n"
		"**mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode** is set to\n"
		"**mvIMPACT::acquire::ctocmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode**\n"
		"modifying this property will have no effect.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistOutputCorrectionMatrixRow2_get", _wrap_ImageProcessing_colorTwistOutputCorrectionMatrixRow2_get, METH_O, "\n"
		"The third row of the output color correction matrix.\n"
		"This property stores the third row of a user defined 3x3 output color correction matrix if\n"
		"**mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode** is set to\n"
		"**mvIMPACT::acquire::ctocmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode**\n"
		"modifying this property will have no effect.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistResultingMatrixRow0_get", _wrap_ImageProcessing_colorTwistResultingMatrixRow0_get, METH_O, "\n"
		"The first row of the resulting color twist matrix.\n"
		"This property will store the first row of the 3x4 resulting color twist matrix. This matrix\n"
		"is created by multiplying the input correction matrix by the color twist matrix by the output correction matrix.\n"
		"Only active matrices will be used to calculate the resulting matrix.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistResultingMatrixRow1_get", _wrap_ImageProcessing_colorTwistResultingMatrixRow1_get, METH_O, "\n"
		"The second row of the resulting color twist matrix.\n"
		"This property will store the second row of the 3x4 resulting color twist matrix. This matrix\n"
		"is created by multiplying the input correction matrix by the color twist matrix by the output correction matrix.\n"
		"Only active matrices will be used to calculate the resulting matrix.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_colorTwistResultingMatrixRow2_get", _wrap_ImageProcessing_colorTwistResultingMatrixRow2_get, METH_O, "\n"
		"The third row of the resulting color twist matrix.\n"
		"This property will store the third row of the 3x4 resulting color twist matrix. This matrix\n"
		"is created by multiplying the input correction matrix by the color twist matrix by the output correction matrix.\n"
		"Only active matrices will be used to calculate the resulting matrix.\n"
		"\n"
		"Since: 2.2.2.\n"
		""},
	 { "ImageProcessing_formatReinterpreterEnable_get", _wrap_ImageProcessing_formatReinterpreterEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable/disable the format reinterpreter filter.\n"
		"This filter can be used if a device transmits data in a non-compliant or incorrect format. Using this filter the incoming\n"
		"data will simply be treated as a different pixel format then. This will **NOT** copy or modify the pixel data but will only\n"
		"adjust some of the elements describing the buffer (e.g. the pixel format and width). When e.g. setting this filter to treat\n"
		"mono data as RGB data, this will result in buffers with a width divided by 3 but RGB pixels instead of mono pixel afterwards.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Since: 2.10.1\n"
		""},
	 { "ImageProcessing_formatReinterpreterMode_get", _wrap_ImageProcessing_formatReinterpreterMode_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure the format reinterpreter filter.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageBufferFormatReinterpreterMode**.\n"
		"\n"
		"Since: 2.10.1\n"
		""},
	 { "ImageProcessing_formatReinterpreterBayerMosaicParity_get", _wrap_ImageProcessing_formatReinterpreterBayerMosaicParity_get, METH_O, "\n"
		"An enumerated integer property defining the new Bayer parity of this buffer.\n"
		"After applying the format reinterpreter this will be the new Bayer parity of the buffer when the filter is operated\n"
		"in one of the ``Mono`` ``To`` ``Mono`` modes.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.\n"
		"\n"
		"Since: 2.31.0\n"
		""},
	 { "ImageProcessing_rotationEnable_get", _wrap_ImageProcessing_rotationEnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable/disable the rotation filter.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Since: 2.13.2\n"
		""},
	 { "ImageProcessing_rotationAngle_get", _wrap_ImageProcessing_rotationAngle_get, METH_O, "\n"
		"The counterclockwise angle at which the image will be rotated.\n"
		"This property will store the counterclockwise angle at which the image will be rotated.\n"
		"\n"
		"Since: 2.13.2\n"
		""},
	 { "ImageProcessing_setSaturation", _wrap_ImageProcessing_setSaturation, METH_VARARGS, "\n"
		" Sets the saturation by using the color twist matrix.\n"
		" The following saturation formula is used:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"      [0.299 + 0.701*K       , 0.587*(1-K) , 0.114*(1-K)     ]\n"
		"      [0.299*(1-K) + 0.701*K , 0.587       , 0.114*(1-K)     ]\n"
		"      [0.299*(1-K) + 0.701*K , 0.587*(1-K) , 0.114 + 0.886*K ]\n"
		"\n"
		" K is the saturation factor\n"
		" K > 1 increases saturation\n"
		" K = 1 means no change\n"
		" 0 < K < 1 decreases saturation\n"
		" K = 0 produces B&W\n"
		" K < 0 inverts color\n"
		"\n"
		" Notes: \n"
		" To enable/disable the saturation the application must write to **mvIMPACT::acquire::ImageProcessing::colorTwistEnable**.\n"
		"\n"
		":type K: float\n"
		":param K: [in] The saturation value.\n"
		""},
	 { "ImageProcessing_getGainOffsetKneeParameter", _wrap_ImageProcessing_getGainOffsetKneeParameter, METH_VARARGS, "\n"
		" Returns a reference to a set of user definable parameters to configure a certain channel of the GainOffsetKnee filter.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" :rtype: :py:class:`GainOffsetKneeChannelParameters`\n"
		" :return: A reference to one of the parameter sets for the GainOffsetKnee filter that\n"
		"     can be altered by the user.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the gain, offset, knee parameter set to be returned\n"
		""},
	 { "ImageProcessing_getGainOffsetKneeParameterCount", _wrap_ImageProcessing_getGainOffsetKneeParameterCount, METH_O, " Returns the number of available user definable parameter sets for the GainOffsetKnee filter."},
	 { "ImageProcessing_getMirrorParameter", _wrap_ImageProcessing_getMirrorParameter, METH_VARARGS, "\n"
		" Returns a reference to a set of user definable parameters to configure mirror filter related features.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" :rtype: :py:class:`MirrorParameters`\n"
		" :return: A reference to one of the parameter sets for mirror filter related features that\n"
		"     can be altered by the user.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the mirror parameter set to be returned\n"
		""},
	 { "ImageProcessing_getMirrorParameterCount", _wrap_ImageProcessing_getMirrorParameterCount, METH_O, " Returns the number of available user definable parameter sets mirror filter related operations."},
	 { "ImageProcessing_getLUTParameter", _wrap_ImageProcessing_getLUTParameter, METH_VARARGS, "\n"
		" Returns a reference to a set of user definable parameters to configure LUT (**L**ook **U**p **T**able) operations.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" :rtype: :py:class:`LUTParameters`\n"
		" :return: A reference to one of the parameter sets for LUT (**L**ook **U**p **T**able) operations that\n"
		"     can be altered by the user.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the LUT parameter set to be returned\n"
		""},
	 { "ImageProcessing_getLUTParameterCount", _wrap_ImageProcessing_getLUTParameterCount, METH_O, " Returns the number of available user definable parameter sets for LUT (**L**ook **U**p **T**able) operations."},
	 { "ImageProcessing_getWBUserSetting", _wrap_ImageProcessing_getWBUserSetting, METH_VARARGS, "\n"
		" Returns a reference to a set of user definable parameters to perform a white balance correction.\n"
		" Pass '0' for the setting that is activated by setting the property **mvIMPACT::acquire::ImageProcessing::whiteBalance**\n"
		" to **mvIMPACT::acquire::wbpUser1**, '1' for\n"
		" **mvIMPACT::acquire::wbpUser2** and so on.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" :rtype: :py:class:`WhiteBalanceSettings`\n"
		" :return: A reference to one of the parameter sets for white balance correction that\n"
		"     can be altered by the user.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the white balance parameter set to be returned\n"
		""},
	 { "ImageProcessing_getWBUserSettingsCount", _wrap_ImageProcessing_getWBUserSettingsCount, METH_O, " Returns the number of available user definable parameter sets for white balance correction."},
	 { "ImageProcessing_swigregister", ImageProcessing_swigregister, METH_O, NULL},
	 { "ImageProcessing_swiginit", ImageProcessing_swiginit, METH_VARARGS, NULL},
	 { "WhiteBalancer_highQualityWhiteBalance", _wrap_WhiteBalancer_highQualityWhiteBalance, METH_O, NULL},
	 { "new_WhiteBalancer", _wrap_new_WhiteBalancer, METH_NOARGS, NULL},
	 { "delete_WhiteBalancer", _wrap_delete_WhiteBalancer, METH_O, NULL},
	 { "WhiteBalancer_swigregister", WhiteBalancer_swigregister, METH_O, NULL},
	 { "WhiteBalancer_swiginit", WhiteBalancer_swiginit, METH_VARARGS, NULL},
	 { "new_Statistics", _wrap_new_Statistics, METH_O, NULL},
	 { "Statistics_reset", _wrap_Statistics_reset, METH_O, "\n"
		"Resets all statistical properties.\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "Statistics_captureTime_s_get", _wrap_Statistics_captureTime_s_get, METH_O, "\n"
		"A float property **(read-only)** containing the overall time an image request spent in the device drivers processing chain.\n"
		"This time is **NOT** the reciprocal of the frame rate, but usually a much longer period of time as it includes the time\n"
		"elapsed from sending the request into the capture queue until the buffer has been placed back into one of the result queues again.\n"
		"This time increases with the amount of requests being used.\n"
		""},
	 { "Statistics_bandwidthConsumed_get", _wrap_Statistics_bandwidthConsumed_get, METH_O, "\n"
		"A float property **(read-only)** containing the current bandwidth consumed by this device in KB/s based on the average buffer size and the timestamps delivered from the device driver.\n"
		"Since: 2.12.3\n"
		""},
	 { "Statistics_errorCount_get", _wrap_Statistics_errorCount_get, METH_O, " An integer property **(read-only)** containing the overall count of image requests which returned with an error since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**."},
	 { "Statistics_abortedRequestsCount_get", _wrap_Statistics_abortedRequestsCount_get, METH_O, " An integer property **(read-only)** containing the overall count of image requests which have been aborted since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**."},
	 { "Statistics_timedOutRequestsCount_get", _wrap_Statistics_timedOutRequestsCount_get, METH_O, " An integer property **(read-only)** containing the overall count of image requests which have timed out since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**."},
	 { "Statistics_framesPerSecond_get", _wrap_Statistics_framesPerSecond_get, METH_O, " A float property **(read-only)** containing the current number of frames captured per second."},
	 { "Statistics_frameCount_get", _wrap_Statistics_frameCount_get, METH_O, "\n"
		"An integer property **(read-only)** containing the overall count of images captured since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**.\n"
		"This counter is incremented regardless of the result a request is returned with thus also e.g. if a request did time out, was aborted(e.g. due to a call to **mvIMPACT::acquire::FunctionInterface::imageRequestReset** or **mvIMPACT::acquire::FunctionInterface::acquisitionStop)** or the data was not completely captured.\n"
		""},
	 { "Statistics_imageProcTime_s_get", _wrap_Statistics_imageProcTime_s_get, METH_O, "\n"
		"An integer property **(read-only)** containing the time (in seconds) needed to process the image data internally.\n"
		"This time might be interesting e.g. if the image data is transformed into a color\n"
		"image by the driver (e.g. when working with Bayer mosaic cameras) or if any other processing function is applied to the\n"
		"image before it is transferred to the user.\n"
		""},
	 { "Statistics_formatConvertTime_s_get", _wrap_Statistics_formatConvertTime_s_get, METH_O, "\n"
		"An integer property **(read-only)** containing the time (in seconds) needed to convert the image data delivered by the hardware and/or active internal driver filter nodes to the format specified by **mvIMPACT::acquire::ImageDestination::pixelFormat** internally.\n"
		"This time will be almost 0 when no custom destination pixel format has been specified and if a custom destination format\n"
		"was selected and this format differs from the pixel format that is transferred by the hardware this time will be a part\n"
		"(or all, but never more) than the time reported by **mvIMPACT::acquire::Statistics::imageProcTime_s**.\n"
		"\n"
		"Since: 1.12.58\n"
		""},
	 { "Statistics_queueTime_s_get", _wrap_Statistics_queueTime_s_get, METH_O, "\n"
		"A float property **(read-only)** containing the average time (in seconds) a **mvIMPACT::acquire::Request** object spends in the request queue of the device.\n"
		"This is the time between a call to **mvIMPACT::acquire::FunctionInterface::imageRequestSingle()** and the time the driver actually uses this buffer\n"
		"to capture data into it or to forward it into a kernel driver.\n"
		""},
	 { "Statistics_lostImagesCount_get", _wrap_Statistics_lostImagesCount_get, METH_O, "\n"
		"An integer property **(read-only)** containing the number of images that have been lost from a continuous image stream coming from a video signal source.\n"
		"Notes: \n"
		"For some devices this value is based on an assumption so it's by no means absolutely accurate, but when this\n"
		"value starts to increase this might indicate that a problem is present.\n"
		"\n"
		"Possible causes (among others) might be:\n"
		"- the capture device or device driver can't cope with the amount of data the video signal source is delivering in the current mode of operation\n"
		"- the capture device or device driver can't transfer all the data to the host PC because of bus bandwidth shortages\n"
		"- the capture device or device driver image request queue ran low because the system is busy doing other things or because of a bug\n"
		"in the application\n"
		"\n"
		"\n"
		"This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)\n"
		"a driver update will fix this.\n"
		""},
	 { "Statistics_framesIncompleteCount_get", _wrap_Statistics_framesIncompleteCount_get, METH_O, "\n"
		"An integer property **(read-only)** containing the overall count of image requests which haven't been captured completely since the **mvIMPACT::acquire::Device** has been opened.\n"
		"This value is a good indicator for bandwidth problems on the device to host connection.\n"
		"\n"
		"Notes: \n"
		"This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)\n"
		"a driver update will fix this.\n"
		""},
	 { "Statistics_missingDataAverage_pc_get", _wrap_Statistics_missingDataAverage_pc_get, METH_O, "\n"
		"A float property **(read-only)** containing the average amount of data missing in frames that haven't been captured completely since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**.\n"
		"This value is a good indicator for bandwidth problems on the device to host connection.\n"
		"\n"
		"Notes: \n"
		"This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)\n"
		"a driver update will fix this.\n"
		""},
	 { "Statistics_retransmitCount_get", _wrap_Statistics_retransmitCount_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the number of retransmit requests issued due to temporary bus bandwidth shortages or other transmission problems since this **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**.\n"
		"This value can be an indicator for transmission problems because of bad signal quality or bus\n"
		"bandwidth shortages in the system.\n"
		"Ideally this property should stay 0 all the time if the system can cope with the amount of data transferred and the signal\n"
		"quality is good. However it might increase slowly and still every frame will be flawless as the driver internally was\n"
		"able to restore the lost data by re-requesting it from the video signal source again.\n"
		"\n"
		"Notes: \n"
		"This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)\n"
		"a driver update will fix this.\n"
		""},
	 { "delete_Statistics", _wrap_delete_Statistics, METH_O, NULL},
	 { "Statistics_swigregister", Statistics_swigregister, METH_O, NULL},
	 { "Statistics_swiginit", Statistics_swiginit, METH_VARARGS, NULL},
	 { "new_FullSettingsBase", _wrap_new_FullSettingsBase, METH_VARARGS, "\n"
		" brief Constructs a new **mvIMPACT::acquire::FullSettingsBase** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "delete_FullSettingsBase", _wrap_delete_FullSettingsBase, METH_O, NULL},
	 { "FullSettingsBase_imageProcessing_get", _wrap_FullSettingsBase_imageProcessing_get, METH_O, " Image processing related properties."},
	 { "FullSettingsBase_imageDestination_get", _wrap_FullSettingsBase_imageDestination_get, METH_O, " Properties to define the result images format."},
	 { "FullSettingsBase_basedOn_get", _wrap_FullSettingsBase_basedOn_get, METH_O, " A string property **(read-only)** containing the name of the setting this setting is based on."},
	 { "FullSettingsBase_swigregister", FullSettingsBase_swigregister, METH_O, NULL},
	 { "FullSettingsBase_swiginit", FullSettingsBase_swiginit, METH_VARARGS, NULL},
	 { "new_SystemSettings", _wrap_new_SystemSettings, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::SystemSettings** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "SystemSettings_requestCount_get", _wrap_SystemSettings_requestCount_get, METH_O, "\n"
		"An integer property defining the number of requests allocated by the driver.\n"
		"Each request object can be used to capture data into. Multiple requests can be processed\n"
		"by a device driver as background tasks.\n"
		"\n"
		"Setting this property to a value at least allowing a driver to capture data for up to 500ms without user interaction (thus 0.5 times the expected frame rate) is highly\n"
		"recommended. Increasing this value will NOT introduce additional latency to your application. The only drawback will be additional RAM consumption by the driver but\n"
		"applications that do not need to copy the request buffers can even benefit from that as the overall memory fragmentation is likely to go down then.\n"
		"Values smaller than 3 most likely result in undesired behaviour and should be avoided unless absolutely needed.\n"
		"\n"
		"Notes: For performance reasons this value can be increased at any time(only exception: Working with the interface layout\n"
		"**mvIMPACT::acquire::dilGenICam** while streaming is active) but can only be\n"
		"decreased when no request object is currently locked by the application and no requests has been\n"
		"queued for acquisition. So modifying this value might require the application to call **mvIMPACT::acquire::FunctionInterface::imageRequestReset**\n"
		"and several calls to **mvIMPACT::acquire::Request::unlock** before.\n"
		"\n"
		"There are not too many reasons to modify the default request count suggested by the device driver. Good reasons include:\n"
		"\n"
		"- a single image is huge compared to the overall system memory(e.g. a single image has 200MB while the system itself only\n"
		"has about 2GB of RAM. Here it might make sense to reduce the number of capture buffers to 1 or 2. Please note that in such a\n"
		"scenario double buffering or live display when one buffer is constantly blocked by the display engine can become a challenge!\n"
		"- the frame rate is high(larger than 100 frames per second) and no frames shall be lost. Here it might make sense to set\n"
		"the number of capture buffers to something like frame rate divided by 2 to 5 as a rule of thumb.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::FunctionInterface::requestCount**\n"
		""},
	 { "SystemSettings_acquisitionMode_get", _wrap_SystemSettings_acquisitionMode_get, METH_O, "\n"
		"An enumerated integer property defining the acquisition mode of the device.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAcquisitionMode**.\n"
		""},
	 { "SystemSettings_acquisitionIdleTimeMax_ms_get", _wrap_SystemSettings_acquisitionIdleTimeMax_ms_get, METH_O, "\n"
		"An integer property defining the maximum time in ms the driver waits for new requests being queued until streaming by the device will automatically be stopped.\n"
		"This property defines the maximum time in milliseconds the driver waits for new **mvIMPACT::acquire::Request** objects being\n"
		"queued by calling **mvIMPACT::acquire::FunctionInterface::imageRequestSingle** once the driver will automatically send an\n"
		"acquisition stop command to a streaming device (such as a GigE Vision or USB3 Vision device) when the driver's request queue has run empty (thus the\n"
		"driver has no more buffers to capture data into).\n"
		"\n"
		"This property will only be taken into account when **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** has been set to\n"
		"**mvIMPACT::acquire::assbDefault**.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every device. Right now only devices operated through the *GenTL* driver package will support\n"
		"this feature.\n"
		"\n"
		"Since: 2.4.1\n"
		""},
	 { "SystemSettings_imageProcessingMode_get", _wrap_SystemSettings_imageProcessingMode_get, METH_O, "\n"
		" An enumerated integer property influencing the behaviour of the internal image processing pipeline.\n"
		" Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageProcessingMode**.\n"
		"\n"
		" Notes: \n"
		" This property will only be available if **mvIMPACT::acquire::Device::userControlledImageProcessingEnable** has been\n"
		" set to **mvIMPACT::acquire::bTrue** before the device is opened.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::Device::userControlledImageProcessingEnable**\n"
		"\n"
		"**mvIMPACT::acquire::Request::hasProcessingBeenSkipped**\n"
		"\n"
		" Since: 2.14.0\n"
		""},
	 { "SystemSettings_imageProcessingMaximumThreadCount_get", _wrap_SystemSettings_imageProcessingMaximumThreadCount_get, METH_O, "\n"
		" An integer property influencing the number of parallel threads used by the internal image processing pipeline.\n"
		"This property can be used to control the size of the internal thread pool used for image processing tasks. Using\n"
		"a value higher than the number of physical CPU cores usually has a negative impact on the performance. Use with care!\n"
		"\n"
		"Notes: \n"
		"This property will only be available on some platforms. Always check if this property is available before using it!\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::SystemSettings::imageProcessingOptimization**\n"
		"\n"
		"**mvIMPACT::acquire::SystemSettings::imageProcessingMode**\n"
		"\n"
		"'ImageProcessing_General_Multithreading'\n"
		"\n"
		" Since: 2.41.0\n"
		""},
	 { "SystemSettings_imageProcessingOptimization_get", _wrap_SystemSettings_imageProcessingOptimization_get, METH_O, "\n"
		"An enumerated integer property influencing the behaviour of the internal image processing algorithms.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageProcessingOptimization**.\n"
		"\n"
		"Since: 2.12.2\n"
		""},
	 { "SystemSettings_featurePollingEnable_get", _wrap_SystemSettings_featurePollingEnable_get, METH_O, "\n"
		" An enumerated integer property defining whether features defining a polling time shall be updated automatically or not.\n"
		" Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"See also: mvIMPACT::acquire::SystemSettings::featurePollingInterval_ms\n"
		""},
	 { "SystemSettings_featurePollingInterval_ms_get", _wrap_SystemSettings_featurePollingInterval_ms_get, METH_O, "\n"
		"An integer property defining the polling interval in ms the driver waits for each iteration before running through update loop again.\n"
		"Some features define a so called ``polling`` ``time``. This is a recommendation by the device/driver stating that this property\n"
		"might change its value without user interaction act a certain rate (e.g. the device temperature could be one example for a\n"
		"feature with such a behaviour). When **mvIMPACT::acquire::SystemSettings::featurePollingEnable** is set to\n"
		"**mvIMPACT::acquire::bTrue** a thread will check every ``featurePollingInterval_ms`` if features need to be updated. This will\n"
		"only cause communication with a device for each feature whose polling time has elapsed.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every device. Right now only devices operated through the *GenTL* driver package will support\n"
		"this feature.\n"
		"\n"
		"Since: 2.18.3\n"
		""},
	 { "SystemSettings_methodPollingInterval_ms_get", _wrap_SystemSettings_methodPollingInterval_ms_get, METH_O, "\n"
		"An integer property defining the polling interval in ms the driver waits during each iteration before checking a methods execution state again.\n"
		"When working with a GenICam compliant device, GenICam method objects need to be checked for their completion status every now\n"
		"and then. This parameter defines how often this shall be done.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every device. Right now only devices operated through the *GenTL* driver package will support\n"
		"this feature.\n"
		"\n"
		"Since: 2.18.3\n"
		""},
	 { "SystemSettings_methodPollingMaxRetryCount_get", _wrap_SystemSettings_methodPollingMaxRetryCount_get, METH_O, "\n"
		" An integer property defining the polling interval in ms the driver waits during each iteration before checking a methods execution state again.\n"
		" When working with a GenICam compliant device, GenICam method objects need to be checked for their completion status every now\n"
		" and then. This parameter defines how often this shall be done at all. A method is checked for completion\n"
		"``methodPollingMaxRetryCount`` * ``methodPollingInterval_ms`` at max. Until then either the device starts to inform the driver\n"
		" that it needs more time **OR** the execution of the method has completed successfully **or** an error will be generated.\n"
		"\n"
		" Notes: \n"
		" This property will not be available for every device. Right now only devices operated through the *GenTL* driver package will support\n"
		" this feature.\n"
		"\n"
		" Since: 2.18.3\n"
		""},
	 { "delete_SystemSettings", _wrap_delete_SystemSettings, METH_O, NULL},
	 { "SystemSettings_swigregister", SystemSettings_swigregister, METH_O, NULL},
	 { "SystemSettings_swiginit", SystemSettings_swiginit, METH_VARARGS, NULL},
	 { "new_ImageMemoryManager", _wrap_new_ImageMemoryManager, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::ImageMemoryManager** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "ImageMemoryManager_mode_get", _wrap_ImageMemoryManager_mode_get, METH_O, "\n"
		"An enumerated integer property containing the mode the memory manager is currently operated in.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMemoryManagerMode**.\n"
		""},
	 { "ImageMemoryManager_allocatedDMAMemory_bytes_get", _wrap_ImageMemoryManager_allocatedDMAMemory_bytes_get, METH_O, " An integer property **(read-only)** containing the size of the allocated DMA memory (in bytes)."},
	 { "ImageMemoryManager_usedDMAMemory_bytes_get", _wrap_ImageMemoryManager_usedDMAMemory_bytes_get, METH_O, " An integer property **(read-only)** containing the size of the DMA memory (in bytes) currently used by the device."},
	 { "ImageMemoryManager_usedBlocks_get", _wrap_ImageMemoryManager_usedBlocks_get, METH_O, " An integer property **(read-only)** containing the number of individual blocks of DMA memory currently used by the device."},
	 { "ImageMemoryManager_poolMode_get", _wrap_ImageMemoryManager_poolMode_get, METH_O, "\n"
		"An enumerated integer property containing the mode the memory managers memory pool is currently operated in.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMemoryManagerPoolMode**.\n"
		""},
	 { "ImageMemoryManager_poolBlockSize_bytes_get", _wrap_ImageMemoryManager_poolBlockSize_bytes_get, METH_O, " An integer property defining the size (in bytes) to use for each block of DMA memory."},
	 { "ImageMemoryManager_poolBlockCount_get", _wrap_ImageMemoryManager_poolBlockCount_get, METH_O, " An integer property **(read-only)** containing the number of individual blocks of DMA memory currently available when using the current pool block size and pool mode."},
	 { "delete_ImageMemoryManager", _wrap_delete_ImageMemoryManager, METH_O, NULL},
	 { "ImageMemoryManager_swigregister", ImageMemoryManager_swigregister, METH_O, NULL},
	 { "ImageMemoryManager_swiginit", ImageMemoryManager_swiginit, METH_VARARGS, NULL},
	 { "new_InfoBlueDevice", _wrap_new_InfoBlueDevice, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::InfoBlueDevice** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "InfoBlueDevice_sensorXRes_get", _wrap_InfoBlueDevice_sensorXRes_get, METH_O, "\n"
		"An integer property **(read-only)** containing the horizontal resolution of the camera sensor.\n"
		"If the device has more than one sensor head, and all these sensor heads can be accessed using the current interface,\n"
		"this property will contain as many values as the devices offers sensor heads.\n"
		""},
	 { "InfoBlueDevice_sensorYRes_get", _wrap_InfoBlueDevice_sensorYRes_get, METH_O, "\n"
		"An integer property **(read-only)** containing the vertical resolution of the camera sensor.\n"
		"If the device has more than one sensor head, and all these sensor heads can be accessed using the current interface,\n"
		"this property will contain as many values as the devices offers sensor heads.\n"
		""},
	 { "InfoBlueDevice_sensorColorMode_get", _wrap_InfoBlueDevice_sensorColorMode_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** containing the type of the sensor (color/mono/...)(if known).\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInfoSensorColorMode**.\n"
		"\n"
		"Notes: \n"
		"If nothing is known about this feature, this property will contain **mvIMPACT::acquire::iscmUnknown**.\n"
		"\n"
		"If the device has more than one sensor head, and all these sensor heads can be accessed using the current interface,\n"
		"this property will contain as many values as the devices offers sensor heads.\n"
		""},
	 { "InfoBlueDevice_sensorType_get", _wrap_InfoBlueDevice_sensorType_get, METH_O, "\n"
		"An enumerated integer property **(read-only)** containing the type of sensor chip of the camera (if known).\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInfoSensorType**.\n"
		"\n"
		"This usually will either be **mvIMPACT::acquire::istCCD** or **mvIMPACT::acquire::istCMOS**.\n"
		"\n"
		"If the device has more than one sensor head, and all these sensor heads can be accessed using the current interface,\n"
		"this property will contain as many values as the devices offers sensor heads.\n"
		""},
	 { "delete_InfoBlueDevice", _wrap_delete_InfoBlueDevice, METH_O, NULL},
	 { "InfoBlueDevice_swigregister", InfoBlueDevice_swigregister, METH_O, NULL},
	 { "InfoBlueDevice_swiginit", InfoBlueDevice_swiginit, METH_VARARGS, NULL},
	 { "new_InfoBlueCOUGAR", _wrap_new_InfoBlueCOUGAR, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::InfoBlueCOUGAR** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "InfoBlueCOUGAR_deviceFPGAVersion_get", _wrap_InfoBlueCOUGAR_deviceFPGAVersion_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the current FPGA version of this device.\n"
		"Notes: \n"
		"This feature is only supported by **mvBlueCOUGAR-S** devices.\n"
		""},
	 { "delete_InfoBlueCOUGAR", _wrap_delete_InfoBlueCOUGAR, METH_O, NULL},
	 { "InfoBlueCOUGAR_swigregister", InfoBlueCOUGAR_swigregister, METH_O, NULL},
	 { "InfoBlueCOUGAR_swiginit", InfoBlueCOUGAR_swiginit, METH_VARARGS, NULL},
	 { "new_InfoBlueFOX", _wrap_new_InfoBlueFOX, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::InfoBlueFOX** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "InfoBlueFOX_firmwareVersion_get", _wrap_InfoBlueFOX_firmwareVersion_get, METH_O, " An integer property **(read-only)** containing the firmware version of this device."},
	 { "InfoBlueFOX_sensorFPGAVersion_get", _wrap_InfoBlueFOX_sensorFPGAVersion_get, METH_O, "\n"
		"An integer property **(read-only)** containing the FPGA version of the camera(if known).\n"
		"Notes: \n"
		"If nothing is known about this feature, this property will contain '-1'.\n"
		""},
	 { "InfoBlueFOX_sensorCaps_get", _wrap_InfoBlueFOX_sensorCaps_get, METH_O, "\n"
		"An integer property **(read-only)** containing a bit mask containing information about the sensors capabilities(if known).\n"
		"Notes: \n"
		"If nothing is known about this feature, this property will contain '-1'.\n"
		""},
	 { "InfoBlueFOX_deviceSensorRevision_get", _wrap_InfoBlueFOX_deviceSensorRevision_get, METH_O, "\n"
		"A 64 bit integer property **(read-only)** containing the current revision of the sensor head of this device.\n"
		"Notes: \n"
		"This feature is currently not supported by all sensors. If a sensor can't provide this information, the value\n"
		"of this property will remain 0 at all time.\n"
		"\n"
		"Since: 1.12.65\n"
		""},
	 { "InfoBlueFOX_userEEPROMSize_get", _wrap_InfoBlueFOX_userEEPROMSize_get, METH_O, "\n"
		"An integer property **(read-only)** containing the size of the user EEPROM that can be accessed using the I2C access features of **mvIMPACT::acquire::I2CControl**.\n"
		"Notes: \n"
		"The size may vary depending on the product. Even different products with the same sensor might report\n"
		"different values here.\n"
		"\n"
		"\n"
		"The user EEPROM uses a virtual I2C address of 0x1A2 for write access and 0x1A3 for read access.\n"
		""},
	 { "InfoBlueFOX_deviceTemperature_get", _wrap_InfoBlueFOX_deviceTemperature_get, METH_O, "\n"
		"A float property **(read-only)** containing the temperature of the selected temperature sensor on the device in degrees Celsius.\n"
		"Notes: \n"
		"This property will not be available for every mvBlueFOX. Right now this feature is only implemented for\n"
		"202d version of the mvBlueFOX.\n"
		"\n"
		"Since: 1.12.62\n"
		""},
	 { "delete_InfoBlueFOX", _wrap_delete_InfoBlueFOX, METH_O, NULL},
	 { "InfoBlueFOX_swigregister", InfoBlueFOX_swigregister, METH_O, NULL},
	 { "InfoBlueFOX_swiginit", InfoBlueFOX_swiginit, METH_VARARGS, NULL},
	 { "DigitalInput_get", _wrap_DigitalInput_get, METH_O, "\n"
		"Returns the current state of this input pin.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the current state of this pin is considered as 'logic 1'\n"
		"    - false otherwise\n"
		""},
	 { "DigitalInput_getDescription", _wrap_DigitalInput_getDescription, METH_O, "\n"
		"Returns a description for this digital input.\n"
		"This might contain connector descriptions or other information like\n"
		"e.g. 'Trigger-In(J8.4/J8.5)', which means, this is the trigger input\n"
		"of connector *J8* pins *4* and *5*.\n"
		""},
	 { "delete_DigitalInput", _wrap_delete_DigitalInput, METH_O, NULL},
	 { "DigitalInput_swigregister", DigitalInput_swigregister, METH_O, NULL},
	 { "DigitalOutput_flip", _wrap_DigitalOutput_flip, METH_O, "\n"
		"Inverts the current state of the digital output and returns the previous state.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the previous state of this pin was considered as 'logic 1'\n"
		"    - false otherwise\n"
		""},
	 { "DigitalOutput_get", _wrap_DigitalOutput_get, METH_O, "\n"
		"Returns the current state of this output pin.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the current state of this pin is considered as 'logic 1'\n"
		"    - false otherwise\n"
		""},
	 { "DigitalOutput_getIsWriteable", _wrap_DigitalOutput_getIsWriteable, METH_O, "\n"
		"Checks if the caller has write/modify access to this digital output.\n"
		"Some devices will offer access to digital outputs, but these outputs can't be switched manually.\n"
		"E.g. a device might offer a digital output that can only be configured to stay either high or\n"
		"low during frame exposure but can't be switched to high at a certain user defined moment. For\n"
		"such an output, this function will return false.\n"
		"\n"
		"If the user calls a function belonging to this class that would modify the state of the\n"
		"associated digital output, an exception will be raised.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the caller is allowed to call write/modify operation for this component.\n"
		"    - false otherwise.\n"
		""},
	 { "DigitalOutput_set", _wrap_DigitalOutput_set, METH_O, " Sets the output pin to 'logic 1'."},
	 { "DigitalOutput_reset", _wrap_DigitalOutput_reset, METH_O, " Sets the output pin to 'logic 0'."},
	 { "DigitalOutput_getDescription", _wrap_DigitalOutput_getDescription, METH_O, "\n"
		"Returns a description for this digital output.\n"
		"This might contain connector descriptions or other information like\n"
		"e.g. 'CC1(J1)', which means, this is the CameraLink(R) control\n"
		"channel 1 of connector *J1*.\n"
		""},
	 { "DigitalOutput_setState", _wrap_DigitalOutput_setState, METH_VARARGS, NULL},
	 { "delete_DigitalOutput", _wrap_delete_DigitalOutput, METH_O, NULL},
	 { "DigitalOutput_swigregister", DigitalOutput_swigregister, METH_O, NULL},
	 { "SyncOutput_frequency_Hz_get", _wrap_SyncOutput_frequency_Hz_get, METH_O, " A float property defining the frequency(in Hertz) for the sync. signal generated by this pin."},
	 { "SyncOutput_lowPart_pc_get", _wrap_SyncOutput_lowPart_pc_get, METH_O, " A float property defining the width in percent the sync. signal stays low during one period. The output signal generated will be a square pulse."},
	 { "SyncOutput_getDescription", _wrap_SyncOutput_getDescription, METH_O, "\n"
		"Returns a description for this sync. output.\n"
		"This might contain connector descriptions or other information like\n"
		"e.g. 'VD-OUT(J9.24)', which means, this is the VD output at connector J9\n"
		"pin 24.\n"
		""},
	 { "delete_SyncOutput", _wrap_delete_SyncOutput, METH_O, NULL},
	 { "SyncOutput_swigregister", SyncOutput_swigregister, METH_O, NULL},
	 { "RTCtrProgramStep_address_get", _wrap_RTCtrProgramStep_address_get, METH_O, "\n"
		"An integer property, which defines the absolute jump address within this **mvIMPACT::acquire::RTCtrProgram**.\n"
		"This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgJumpLoc**.\n"
		""},
	 { "RTCtrProgramStep_frameID_get", _wrap_RTCtrProgramStep_frameID_get, METH_O, "\n"
		"An integer property, which defines the frame ID of the triggered image **mvIMPACT::acquire::RTCtrProgram**.\n"
		"This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgTriggerSet**.\n"
		""},
	 { "RTCtrProgramStep_clocks_us_get", _wrap_RTCtrProgramStep_clocks_us_get, METH_O, "\n"
		"An integer property, which defines the waiting time **mvIMPACT::acquire::RTCtrProgram**.\n"
		"This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgWaitClocks**.\n"
		""},
	 { "RTCtrProgramStep_digitalInputs_get", _wrap_RTCtrProgramStep_digitalInputs_get, METH_O, "\n"
		"An enumerated integer property to define for which digital input state this program step waits for.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigIOState**.\n"
		"\n"
		"This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgWaitDigin**.\n"
		""},
	 { "RTCtrProgramStep_digitalOutputs_get", _wrap_RTCtrProgramStep_digitalOutputs_get, METH_O, "\n"
		"An enumerated integer property to define how to set the digital outputs of this device.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigIOState**.\n"
		"\n"
		"This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgSetDigout**.\n"
		""},
	 { "RTCtrProgramStep_sensorHeads_get", _wrap_RTCtrProgramStep_sensorHeads_get, METH_O, "\n"
		"An enumerated integer property to define which sensor heads to trigger (for devices with more than one sensor head).\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigIOState**.\n"
		"\n"
		"This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgTriggerSet**\n"
		"or **mvIMPACT::acquire::rtctrlProgTriggerReset**.\n"
		""},
	 { "RTCtrProgramStep_opCode_get", _wrap_RTCtrProgramStep_opCode_get, METH_O, "\n"
		"An enumerated integer property defining the general purpose of this **mvIMPACT::acquire::RTCtrProgramStep** object.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRTProgOpCodes**.\n"
		""},
	 { "RTCtrProgramStep_controllerRegister_get", _wrap_RTCtrProgramStep_controllerRegister_get, METH_O, "\n"
		"An integer property, which defines the index of the controller register to refer in this **mvIMPACT::acquire::RTCtrProgramStep**.\n"
		"This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to\n"
		"**mvIMPACT::acquire::rtctrlProgRegisterSet**, **mvIMPACT::acquire::rtctrlProgRegisterAdd**,\n"
		"**mvIMPACT::acquire::rtctrlProgRegisterSub**, **mvIMPACT::acquire::rtctrlProgJumpLocOnZero**\n"
		"or **mvIMPACT::acquire::rtctrlProgJumpLocOnNotZero**.\n"
		"\n"
		"Notes: \n"
		"This feature will not be available for every device offering a HRTC. It will be available if the translation\n"
		"dictionary of the property **mvIMPACT::acquire::RTCtrProgramStep::opCode** contains\n"
		"**mvIMPACT::acquire::rtctrlProgRegisterSet**, **mvIMPACT::acquire::rtctrlProgRegisterAdd**,\n"
		"**mvIMPACT::acquire::rtctrlProgRegisterSub**, **mvIMPACT::acquire::rtctrlProgJumpLocOnZero**\n"
		"or **mvIMPACT::acquire::rtctrlProgJumpLocOnNotZero**.\n"
		"\n"
		"Read the properties translation dictionary with\n"
		"the functions **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictValue**.\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		""},
	 { "RTCtrProgramStep_registerValue_get", _wrap_RTCtrProgramStep_registerValue_get, METH_O, "\n"
		"An integer property, which defines the a value to associate with a register access in this **mvIMPACT::acquire::RTCtrProgramStep**.\n"
		"This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to\n"
		"**mvIMPACT::acquire::rtctrlProgRegisterSet**, **mvIMPACT::acquire::rtctrlProgRegisterAdd**\n"
		"or **mvIMPACT::acquire::rtctrlProgRegisterSub**.\n"
		"\n"
		"Notes: \n"
		"This feature will not be available for every device offering a HRTC. It will be available if the translation\n"
		"dictionary of the property **mvIMPACT::acquire::RTCtrProgramStep::opCode** contains\n"
		"**mvIMPACT::acquire::rtctrlProgRegisterSet**, **mvIMPACT::acquire::rtctrlProgRegisterAdd**,\n"
		"or **mvIMPACT::acquire::rtctrlProgRegisterSub**.\n"
		"\n"
		"Read the properties translation dictionary with\n"
		"the functions **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictValue**.\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		""},
	 { "delete_RTCtrProgramStep", _wrap_delete_RTCtrProgramStep, METH_O, NULL},
	 { "RTCtrProgramStep_swigregister", RTCtrProgramStep_swigregister, METH_O, NULL},
	 { "new_RTCtrProgram", _wrap_new_RTCtrProgram, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::RTCtrProgram** from an existing one.\n"
		":type src: :py:class:`RTCtrProgram`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::RTCtrProgram** object, this object shall be created from\n"
		""},
	 { "delete_RTCtrProgram", _wrap_delete_RTCtrProgram, METH_O, " Class destructor."},
	 { "RTCtrProgram_setProgramSize", _wrap_RTCtrProgram_setProgramSize, METH_VARARGS, "\n"
		" A function to define the number of instructions this program should consist of.\n"
		":type newSize: int\n"
		":param newSize: [in] The new number of program instructions\n"
		""},
	 { "RTCtrProgram_getProgramSize", _wrap_RTCtrProgram_getProgramSize, METH_O, "\n"
		"Returns the number of program instructions for this program.\n"
		":rtype: int\n"
		":return: The number of program instructions for this program.\n"
		""},
	 { "RTCtrProgram_programStep", _wrap_RTCtrProgram_programStep, METH_VARARGS, "\n"
		" Returns a pointer to a program instruction of the program.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" :rtype: :py:class:`RTCtrProgramStep`\n"
		" :return: A pointer to a program instruction of the program.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The index of the program instruction to obtain.\n"
		""},
	 { "RTCtrProgram_mode_get", _wrap_RTCtrProgram_mode_get, METH_O, "\n"
		"An enumerated integer property defining the current state this program is into.\n"
		"In order to affect the behaviour of the image acquisition an **mvIMPACT::acquire::RTCtrProgram** must be in\n"
		"running mode. Apart from that the property **triggerSource** must be set\n"
		"appropriately.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRTCtrlModes**.\n"
		""},
	 { "RTCtrProgram_filename_get", _wrap_RTCtrProgram_filename_get, METH_O, "\n"
		" A string property storing the filename for this program.\n"
		" **mvIMPACT::acquire::RTCtrProgram** s can be stored and loaded from/to XML files.\n"
		" To do this, this property must be set to the desired filename.\n"
		" See also: \n"
		" **mvIMPACT::acquire::RTCtrProgram::load**,\n"
		"**mvIMPACT::acquire::RTCtrProgram::save**\n"
		""},
	 { "RTCtrProgram_programState_get", _wrap_RTCtrProgram_programState_get, METH_O, " A string property **(read-only)** containing information about the current state of the program."},
	 { "RTCtrProgram_load", _wrap_RTCtrProgram_load, METH_O, "\n"
		"Loads an existing program specified by the property **mvIMPACT::acquire::RTCtrProgram::fileName**.\n"
		"The default file extension for these programs is '*.rtp'. If the user doesn't\n"
		"specify this file extension, it is appended automatically. Only\n"
		"files of this type can be loaded by this function.\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "RTCtrProgram_save", _wrap_RTCtrProgram_save, METH_O, "\n"
		"Stores the current state of the program under the name specified by the property **mvIMPACT::acquire::RTCtrProgram::filename**.\n"
		"The default file extension for files stored using this function is '*.rtp'. If\n"
		"the user doesn't specify this file extension, it is appended automatically. Only\n"
		"files of this type can be loaded by the function **mvIMPACT::acquire::RTCtrProgram::load**.\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "RTCtrProgram_swigregister", RTCtrProgram_swigregister, METH_O, NULL},
	 { "RTCtrProgram_swiginit", RTCtrProgram_swiginit, METH_VARARGS, NULL},
	 { "PulseStartConfiguration_number", _wrap_PulseStartConfiguration_number, METH_O, " Returns the internal number associated with this pulse start configuration."},
	 { "PulseStartConfiguration_pulseStartTrigger_get", _wrap_PulseStartConfiguration_pulseStartTrigger_get, METH_O, "\n"
		"An enumerated integer property that will define how/when a digital signal is generated by the device.\n"
		"When certain digital output signals\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TPulseStartTrigger**.\n"
		"\n"
		"Notes: \n"
		"Not every device will offer the same options.\n"
		"Check for valid modes by reading the properties translation dictionary with\n"
		"the functions **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictValue**.\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		""},
	 { "PulseStartConfiguration_digitalSignal_get", _wrap_PulseStartConfiguration_digitalSignal_get, METH_O, "\n"
		"An enumerated property to define one or more signals that will trigger the creation of the associated output signals.\n"
		"This property will be visible and thus active when **mvIMPACT::acquire::PulseStartConfiguration::digitalSignal** is switched\n"
		"to **mvIMPACT::acquire::pstDigitalSignal**.\n"
		"\n"
		"Depending on the device one or more signals can be defined as 'active for output signal creation'. When more than one signal can be\n"
		"defined, calling **mvIMPACT::acquire::PropertyIDigitalSignal::allowsValueCombinations** will return true.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigitalSignal**.\n"
		"\n"
		"**mvHYPERION** **specific**:\n"
		"Currently when more than one signal can be defined here, these signals will have an 'or relationship', which means that when any of these\n"
		"signals is detected, it will trigger the creation of the associated output signals.\n"
		"\n"
		"The following signals are defined:\n"
		"\n"
		"\n"
		"  |enum Value\n"
		"  |Associated signal\n"
		"|\n"
		"-\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal1\n"
		"  |Line Valid(J1)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal2\n"
		"  |Line Valid(J2)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal3\n"
		"  |Frame Valid(J1)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal4\n"
		"  |Frame Valid(J2)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal5\n"
		"  |Trigger-In(J3.4/J3.5)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal6\n"
		"  |Sync-In(J3.6/J3.7)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal7\n"
		"  |Trigger-In(J4.4/J4.5)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal8\n"
		"  |Sync-In(J4.6/J4.7)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal9\n"
		"  |DigIn0(J6.9)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal10\n"
		"  |DigIn1(J6.10)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal11\n"
		"  |DigIn2(J6.11)\n"
		"|\n"
		"\n"
		"  |mvIMPACT::acquire::dsSignal12\n"
		"  |DigIn3(J6.12)\n"
		"|\n"
		""},
	 { "PulseStartConfiguration_divider_get", _wrap_PulseStartConfiguration_divider_get, METH_O, "\n"
		"An integer property defining a factor by which the external input signal shall divided.\n"
		"Every *divider-value* pulse will be used then. All others will be skipped.\n"
		""},
	 { "PulseStartConfiguration_frequency_Hz_get", _wrap_PulseStartConfiguration_frequency_Hz_get, METH_O, "\n"
		"A float property defining the frequency in Hz. for the creation of the output signals associated with configuration.\n"
		"This property will be visible and thus active when **mvIMPACT::acquire::PulseStartConfiguration::digitalSignal** is switched\n"
		"to **mvIMPACT::acquire::pstPeriodically**.\n"
		""},
	 { "PulseStartConfiguration_triggerMoment_get", _wrap_PulseStartConfiguration_triggerMoment_get, METH_O, "\n"
		"An enumerated integer property defining the exact moment when this pulse start configuration shall be triggered.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TTriggerMoment**.\n"
		""},
	 { "delete_PulseStartConfiguration", _wrap_delete_PulseStartConfiguration, METH_O, NULL},
	 { "PulseStartConfiguration_swigregister", PulseStartConfiguration_swigregister, METH_O, NULL},
	 { "delete_IOSubSystem", _wrap_delete_IOSubSystem, METH_O, NULL},
	 { "IOSubSystem_getPulseStartConfiguration", _wrap_IOSubSystem_getPulseStartConfiguration, METH_VARARGS, "\n"
		" Returns a pointer to a **mvIMPACT::acquire::PulseStartConfiguration** associated with this device.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the pulse start configuration to return\n"
		""},
	 { "IOSubSystem_getPulseStartConfigurationCount", _wrap_IOSubSystem_getPulseStartConfigurationCount, METH_O, " Returns the number of **mvIMPACT::acquire::PulseStartConfiguration** objects available for the **mvIMPACT::acquire::Device** associated with this object."},
	 { "IOSubSystem_getRTCtrProgram", _wrap_IOSubSystem_getRTCtrProgram, METH_VARARGS, "\n"
		" Returns a pointer to a **mvIMPACT::acquire::RTCtrProgram** associated with this device.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the real time controller program to return\n"
		""},
	 { "IOSubSystem_getRTCtrProgramCount", _wrap_IOSubSystem_getRTCtrProgramCount, METH_O, " Returns the number of **mvIMPACT::acquire::RTCtrProgram** s available for the **mvIMPACT::acquire::Device** associated with this object."},
	 { "IOSubSystem_getInputCount", _wrap_IOSubSystem_getInputCount, METH_O, " Returns the number of **mvIMPACT::acquire::DigitalInput** s available for the **mvIMPACT::acquire::Device** associated with this object."},
	 { "IOSubSystem_readInputRegister", _wrap_IOSubSystem_readInputRegister, METH_O, "\n"
		"Returns the current state of the digital input register.\n"
		"This function can be used to read all digital inputs as a single value. Each\n"
		"bit represents the status of one digital output pin.\n"
		"\n"
		"**EXAMPLE**\n"
		"\n"
		"A value of '3' returned by this function means that digital inputs 0 and 1 are\n"
		"currently have a voltage considered as logical '1' applied to them.\n"
		""},
	 { "IOSubSystem_getInput", _wrap_IOSubSystem_getInput, METH_VARARGS, "\n"
		" Returns a const pointer to a **mvIMPACT::acquire::DigitalInput** object.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* references an invalid pin an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" Notes: \n"
		" The possibility to access the digital inputs of a device as single objects is\n"
		" just provided for convenience. The same thing can be achieved by calling the\n"
		" function **mvIMPACT::acquire::IOSubSystem::readInputRegister**.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the digital input.\n"
		""},
	 { "IOSubSystem_getOutput", _wrap_IOSubSystem_getOutput, METH_VARARGS, "\n"
		" Returns a pointer to a **mvIMPACT::acquire::DigitalOutput** object.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* references an invalid pin an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" Notes: \n"
		" The possibility to access the digital outputs of a device as single objects is\n"
		" just provided for convenience. The same thing can be achieved by calling the function\n"
		" **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with the corresponding bit mask.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the digital output.\n"
		""},
	 { "IOSubSystem_getOutputCount", _wrap_IOSubSystem_getOutputCount, METH_O, " Returns the number of digital outputs available for the **mvIMPACT::acquire::Device** associated with this object."},
	 { "IOSubSystem_readOutputRegister", _wrap_IOSubSystem_readOutputRegister, METH_O, "\n"
		"Returns the current state of the digital output register.\n"
		"This function can be used to read all digital outputs as a single value. Each\n"
		"bit represents the status of one digital output pin.\n"
		"\n"
		"**EXAMPLE**\n"
		"\n"
		"A value of '3' returned by this function means that digital output 0 and 1 are\n"
		"currently set to high.\n"
		""},
	 { "IOSubSystem_writeOutputRegister", _wrap_IOSubSystem_writeOutputRegister, METH_VARARGS, "\n"
		" Alters the state of the digital output register.\n"
		" This function can be used to alter the state of certain (or all) digital outputs\n"
		" with a single function call. By working with the parameter *mask* certain bits\n"
		" can remain unaffected.\n"
		"\n"
		" **EXAMPLE**\n"
		"\n"
		" If the previous state of a digital output register was '5', which means that outputs\n"
		" 0 and 2 are set to high a call to\n"
		" **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with\n"
		" *value* set to 2 and *mask* set to 3 would result in '6' as the new value for the\n"
		" output register. Pin 2 will remain unaffected, as *mask* states just to modify\n"
		" pin 0 and 1 ( 3 = 00000011 binary ).\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     currentValue = 5, mask = 3, value = 2\n"
		"     ( currentValue  ~mask ) | value - new Value\n"
		"     ( 00000101b(current value)  11111100(~mask) ) | 00000010(value) - 0000110(new value of the register)\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to be applied to the output register\n"
		":type mask: int\n"
		":param mask: [in] The mask to specify which pins to modify. A bit set to '1' in this parameter means that the state of this output has to adopt its style according to the value in *value*.\n"
		""},
	 { "IOSubSystem_swigregister", IOSubSystem_swigregister, METH_O, NULL},
	 { "new_IOSubSystemBlueFOX", _wrap_new_IOSubSystemBlueFOX, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::IOSubSystemBlueFOX** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "IOSubSystemBlueFOX_readInputRegisterAtomic", _wrap_IOSubSystemBlueFOX_readInputRegisterAtomic, METH_O, "\n"
		"Returns the current state of the digital input register.\n"
		"This function can be used to read all digital inputs as a single value **at** the same time. Each\n"
		"bit represents the status of one digital output pin.\n"
		"\n"
		"**EXAMPLE**\n"
		"\n"
		"A value of '3' returned by this function means that digital inputs 0 and 1 are\n"
		"currently have a voltage considered as logical '1' applied to them.\n"
		""},
	 { "IOSubSystemBlueFOX_readOutputRegisterAtomic", _wrap_IOSubSystemBlueFOX_readOutputRegisterAtomic, METH_O, "\n"
		"Returns the current state of the digital output register.\n"
		"This function can be used to read all digital outputs as a single value **at** the same time. Each\n"
		"bit represents the status of one digital output pin.\n"
		"\n"
		"**EXAMPLE**\n"
		"\n"
		"A value of '3' returned by this function means that digital output 0 and 1 are\n"
		"currently set to high.\n"
		""},
	 { "IOSubSystemBlueFOX_writeOutputRegister", _wrap_IOSubSystemBlueFOX_writeOutputRegister, METH_VARARGS, "\n"
		" Alters the state of the digital output register.\n"
		" This function can be used to alter the state of certain (or all) digital outputs\n"
		" with a single function call. By working with the parameter *mask* certain bits\n"
		" can remain unaffected.\n"
		"\n"
		" **EXAMPLE**\n"
		"\n"
		" If the previous state of a digital output register was '5', which means that outputs\n"
		" 0 and 2 are set to high a call to\n"
		" **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with\n"
		" *value* set to 2 and *mask* set to 3 would result in '6' as the new value for the\n"
		" output register. Pin 2 will remain unaffected, as *mask* states just to modify\n"
		" pin 0 and 1 ( 3 = 00000011 binary ).\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to be applied to the output register\n"
		":type mask: int\n"
		":param mask: [in] The mask to specify which pins to modify. A bit set to '1' in this parameter means that the state of this output has to adopt its style according to the value in *value*.\n"
		""},
	 { "IOSubSystemBlueFOX_writeOutputRegisterAtomic", _wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic, METH_VARARGS, "\n"
		" Alters the state of the digital output register.\n"
		" This function can be used to alter the state of certain (or all) digital outputs\n"
		" with a single function call **at** the same time. By working with the parameter *mask*\n"
		" certain bits can remain unaffected.\n"
		"\n"
		" **EXAMPLE**\n"
		"\n"
		" If the previous state of a digital output register was '5', which means that outputs\n"
		" 0 and 2 are set to high a call to\n"
		" **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with\n"
		" *value* set to 2 and *mask* set to 3 would result in '6' as the new value for the\n"
		" output register. Pin 2 will remain unaffected, as *mask* states just to modify\n"
		" pin 0 and 1 ( 3 = 00000011 binary ).\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to be applied to the output register\n"
		":type mask: int\n"
		":param mask: [in] The mask to specify which pins to modify. A bit set to '1' in this parameter means that the state of this output has to adopt its style according to the value in *value*.\n"
		""},
	 { "IOSubSystemBlueFOX_digitalInputThreshold_get", _wrap_IOSubSystemBlueFOX_digitalInputThreshold_get, METH_O, "\n"
		"An enumerated integer property defining the threshold for the digital inputs in Volt.\n"
		"If a voltage applied to the digital input lies above the threshold this pin\n"
		"will be considered as 'logic 1' otherwise it will be considered as 'logic 0'.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXDigitalInputThreshold**.\n"
		"\n"
		"Notes: \n"
		"This property is **read-only** for **mvBlueFOX-M** devices and will always be 2V.\n"
		""},
	 { "delete_IOSubSystemBlueFOX", _wrap_delete_IOSubSystemBlueFOX, METH_O, NULL},
	 { "IOSubSystemBlueFOX_swigregister", IOSubSystemBlueFOX_swigregister, METH_O, NULL},
	 { "IOSubSystemBlueFOX_swiginit", IOSubSystemBlueFOX_swiginit, METH_VARARGS, NULL},
	 { "new_IOSubSystemCommon", _wrap_new_IOSubSystemCommon, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::IOSubSystemCommon** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "IOSubSystemCommon_writeOutputRegister", _wrap_IOSubSystemCommon_writeOutputRegister, METH_VARARGS, "\n"
		" Alters the state of the digital output register.\n"
		" This function can be used to alter the state of certain (or all) digital outputs\n"
		" with a single function call. By working with the parameter *mask* certain bits\n"
		" can remain unaffected.\n"
		"\n"
		" **EXAMPLE**\n"
		"\n"
		" If the previous state of a digital output register was '5', which means that outputs\n"
		" 0 and 2 are set to high a call to\n"
		" **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with\n"
		" *value* set to 2 and *mask* set to 3 would result in '6' as the new value for the\n"
		" output register. Pin 2 will remain unaffected, as *mask* states just to modify\n"
		" pin 0 and 1 ( 3 = 00000011 binary ).\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to be applied to the output register\n"
		":type mask: int\n"
		":param mask: [in] The mask to specify which pins to modify. A bit set to '1' in this parameter means that the state of this output has to adopt its style according to the value in *value*.\n"
		""},
	 { "delete_IOSubSystemCommon", _wrap_delete_IOSubSystemCommon, METH_O, NULL},
	 { "IOSubSystemCommon_swigregister", IOSubSystemCommon_swigregister, METH_O, NULL},
	 { "IOSubSystemCommon_swiginit", IOSubSystemCommon_swiginit, METH_VARARGS, NULL},
	 { "new_OutputSignalGeneratorBlueDevice", _wrap_new_OutputSignalGeneratorBlueDevice, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new **mvIMPACT::acquire::OutputSignalGeneratorBlueDevice** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::OutputSignalGeneratorBlueDevice** from and existing one.\n"
		":type src: :py:class:`OutputSignalGeneratorBlueDevice`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::OutputSignalGeneratorBlueDevice** object, this object shall be created from\n"
		""},
	 { "delete_OutputSignalGeneratorBlueDevice", _wrap_delete_OutputSignalGeneratorBlueDevice, METH_O, " Class destructor."},
	 { "OutputSignalGeneratorBlueDevice_undefineSignal", _wrap_OutputSignalGeneratorBlueDevice_undefineSignal, METH_VARARGS, "\n"
		" Removes the signal definition from the specified output pin.\n"
		" Whenever a signal has been defined for a a certain digital output\n"
		" pin, this pin can no longer controlled using the corresponding functions\n"
		" in the class **mvIMPACT::acquire::DigitalOutput**. This function removes the\n"
		" signal definition and hands back manual control of that digital output to the user.\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.\n"
		""},
	 { "OutputSignalGeneratorBlueDevice_canCreateExposeActiveSignal", _wrap_OutputSignalGeneratorBlueDevice_canCreateExposeActiveSignal, METH_VARARGS, "\n"
		" Checks whether the specified output can be used to create an inverted expose active signal.\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.\n"
		""},
	 { "OutputSignalGeneratorBlueDevice_canInvertSignal", _wrap_OutputSignalGeneratorBlueDevice_canInvertSignal, METH_VARARGS, "\n"
		" Checks whether the specified output can be used to create an inverted version of a certain signal.\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.\n"
		""},
	 { "OutputSignalGeneratorBlueDevice_getOutputMode", _wrap_OutputSignalGeneratorBlueDevice_getOutputMode, METH_VARARGS, "\n"
		" Returns the current mode a digital output is operated in. If the mode is not selectable for the current output an exception will be raised.\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.\n"
		""},
	 { "OutputSignalGeneratorBlueDevice_isOutputModeActive", _wrap_OutputSignalGeneratorBlueDevice_isOutputModeActive, METH_VARARGS, "\n"
		" Checks whether the specified output is currently operated in a certain mode.\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.\n"
		":type mode: int\n"
		":param mode: [in] The mode the specified output shall be checked for.\n"
		""},
	 { "OutputSignalGeneratorBlueDevice_isSignalInverted", _wrap_OutputSignalGeneratorBlueDevice_isSignalInverted, METH_VARARGS, "\n"
		" Checks whether the specified output will currently invert a certain internal signal.\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.\n"
		""},
	 { "OutputSignalGeneratorBlueDevice_setOutputMode", _wrap_OutputSignalGeneratorBlueDevice_setOutputMode, METH_VARARGS, "\n"
		" This function will configure the digital output to operate in a certain mode.\n"
		" After calling this function the digital output will be operated in the mode specified by\n"
		" *mode*.\n"
		"\n"
		" Valid values for *constant* are defined by the enum **mvIMPACT::acquire::TDeviceDigitalOutputMode**.\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.\n"
		":type mode: int\n"
		":param mode: [in] The mode the specified output shall be operated in. If the mode passed to the function is not available for the output or the device an exception will be raised.\n"
		":type boInverted: boolean\n"
		":param boInverted: [in] Set this parameter to true, to invert the exposure signal\n"
		""},
	 { "OutputSignalGeneratorBlueDevice_swigregister", OutputSignalGeneratorBlueDevice_swigregister, METH_O, NULL},
	 { "OutputSignalGeneratorBlueDevice_swiginit", OutputSignalGeneratorBlueDevice_swiginit, METH_VARARGS, NULL},
	 { "new_IOSubSystemFrameGrabber", _wrap_new_IOSubSystemFrameGrabber, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::IOSubSystemFrameGrabber** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "IOSubSystemFrameGrabber_getHDOutputCount", _wrap_IOSubSystemFrameGrabber_getHDOutputCount, METH_O, " Returns the number of available HD output pins for the **mvIMPACT::acquire::Device** associated with this object."},
	 { "IOSubSystemFrameGrabber_HDOutput", _wrap_IOSubSystemFrameGrabber_HDOutput, METH_VARARGS, "\n"
		" Returns a pointer to a **mvIMPACT::acquire::SyncOutput** object that represents a HD output for this device.\n"
		" *nr* **MUST** be a valid number ( larger or equal than 0 and smaller than the\n"
		" value returned by **mvIMPACT::acquire::IOSubSystemFrameGrabber::getHDOutputCount**.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* references an invalid pin an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" :rtype: :py:class:`SyncOutput`\n"
		" :return: A pointer to a **mvIMPACT::acquire::SyncOutput** object.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the HD output to return.\n"
		""},
	 { "IOSubSystemFrameGrabber_getVDOutputCount", _wrap_IOSubSystemFrameGrabber_getVDOutputCount, METH_O, " Returns the number of available VD output pins for the **mvIMPACT::acquire::Device** associated with this object."},
	 { "IOSubSystemFrameGrabber_VDOutput", _wrap_IOSubSystemFrameGrabber_VDOutput, METH_VARARGS, "\n"
		" Returns a pointer to a **mvIMPACT::acquire::SyncOutput** object that represents a VD output for this device.\n"
		" *nr* **MUST** be a valid number ( larger or equal than 0 and smaller than the\n"
		" value returned by **mvIMPACT::acquire::IOSubSystemFrameGrabber::getVDOutputCount**.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* references an invalid pin an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" :rtype: :py:class:`SyncOutput`\n"
		" :return: A pointer to a **mvIMPACT::acquire::SyncOutput** object.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the VD output to return.\n"
		""},
	 { "IOSubSystemFrameGrabber_syncOutputMode_get", _wrap_IOSubSystemFrameGrabber_syncOutputMode_get, METH_O, "\n"
		"An enumerated integer property defining the current mode for sync. signal creation.\n"
		"Sometimes it's desired to create a signal to sync. cameras connected to a capture device.\n"
		"E.g. when capturing 3 monochrome cameras in parallel these should be synchronized. Therefore\n"
		"some devices can create HD and VD signals that synchronize the connected cameras.\n"
		"\n"
		"To create sync. signals this property must be set either to **mvIMPACT::acquire::dsomNonInterlaced**\n"
		"or **mvIMPACT::acquire::dsomInterlaced**.\n"
		"\n"
		"In interlaced mode only the frequency of the VD signals can be modified, while in non-interlaced\n"
		"mode the width (in percent) the signal stays low can be modified as well.\n"
		"\n"
		"Now e.g. to sync. two or more CCIR compliant cameras connected to a capture device that can\n"
		"create sync. signals, the HD signals must be generated with a CCIR compliant frequency.\n"
		"The function **mvIMPACT::acquire::IOSubSystemFrameGrabber::HDOutput** can be used to access the\n"
		"desired output pin. Then its property **mvIMPACT::acquire::SyncOutput::frequency_Hz** is\n"
		"set to 15625 Hz (CCIR standard). The remaining values can be left untouched. The capture device\n"
		"will no generate HD signals with the desired frequency and VD outputs with the frequency\n"
		"stored by the property **mvIMPACT::acquire::SyncOutput::frequency_Hz** belonging to the\n"
		"pointer to the object returned by a call to **mvIMPACT::acquire::IOSubSystemFrameGrabber::VDOutput**.\n"
		""},
	 { "delete_IOSubSystemFrameGrabber", _wrap_delete_IOSubSystemFrameGrabber, METH_O, NULL},
	 { "IOSubSystemFrameGrabber_swigregister", IOSubSystemFrameGrabber_swigregister, METH_O, NULL},
	 { "IOSubSystemFrameGrabber_swiginit", IOSubSystemFrameGrabber_swiginit, METH_VARARGS, NULL},
	 { "new_OutputSignalGeneratorFrameGrabber", _wrap_new_OutputSignalGeneratorFrameGrabber, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber** from an existing one.\n"
		":type src: :py:class:`OutputSignalGeneratorFrameGrabber`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber** object, this object shall be created from\n"
		""},
	 { "delete_OutputSignalGeneratorFrameGrabber", _wrap_delete_OutputSignalGeneratorFrameGrabber, METH_O, " Class destructor."},
	 { "OutputSignalGeneratorFrameGrabber_definePulse", _wrap_OutputSignalGeneratorFrameGrabber_definePulse, METH_VARARGS, "\n"
		" Assigns a single pulse to a digital output.\n"
		" Whenever a single pulse of a certain duration and polarity shall be generated\n"
		" on a digital output as a reaction on a trigger signal that was either generated by one of\n"
		" digital inputs of the device or software this is the right function to use.\n"
		"\n"
		" When the signal is generated can be defined by the properties\n"
		" **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::pulseStartEvent** and\n"
		" **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::imageTrigger**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::undefineSignal**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		":type polarity: int\n"
		":param polarity: [in] The polarity of the pulse to generate. - 0: The pulse will be low for *width_pclk* and high otherwise - 1: The pulse will be high for *width_pclk* and high otherwise\n"
		":type delay: int\n"
		":param delay: [in] The delay after the trigger event before a signal generation starts\n"
		":type width: int\n"
		":param width: [in] The width of the pulse to generate\n"
		":type pPulseStartConfiguration: :py:class:`PulseStartConfiguration`\n"
		":param pPulseStartConfiguration: [in] The pulse start configuration to be used for this pulse sequence. Not every device will support the use of pulse start configurations. Valid objects that can be passed to this function can be obtained from a call to **mvIMPACT::acquire::IOSubSystem::getPulseStartConfiguration**, and **mvIMPACT::acquire::IOSubSystem::getPulseStartConfigurationCount**. If objects of these type are not supported, pass 0 or ignore this parameter. In that case the property **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::imageTrigger** will define the start condition for the signal output.\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_definePulseSequence", _wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence, METH_VARARGS, "\n"
		" Assigns a complex signal to a digital output.\n"
		" This function can be used when a complex signal shall be generated\n"
		" on a digital output as a reaction on a trigger signal that was either generated by one of\n"
		" digital inputs of the device or software.\n"
		"\n"
		" When the signal is generated can be defined by the properties\n"
		" **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::pulseStartEvent** and\n"
		" **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::imageTrigger**.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::undefineSignal**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		":type startLevel: int\n"
		":param startLevel: [in] The start level of the generated signal. - 0: The signal will start with 'low' - 1: The signal will start with 'high'\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [in] An array of integer values. Each values defines a switch in polarity of the signal after 'x' us. An array containing '1000', '2000' therefore will describe a signal starting with *startLevel*, switches polarity after 1000 us and then again switches polarity after 2000 us.\n"
		":type pPulseStartConfiguration: :py:class:`PulseStartConfiguration`\n"
		":param pPulseStartConfiguration: [in] The pulse start configuration to be used for this pulse sequence. Not every device will support the use of pulse start configurations. Valid objects that can be passed to this function can be obtained from a call to **mvIMPACT::acquire::IOSubSystem::getPulseStartConfiguration**, and **mvIMPACT::acquire::IOSubSystem::getPulseStartConfigurationCount**. If objects of these type are not supported, pass 0 or ignore this parameter. In that case the property **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::imageTrigger** will define the start condition for the signal output.\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes", _wrap_OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes, METH_VARARGS, "\n"
		" Receives a list of valid signals that can be passed directly to a certain digital output pin.\n"
		" Whenever it is necessary to output a certain signal (e.g. a digital input signal connected to the device or\n"
		" an internal digital signal like e.g. a frame valid signal) to a digital output of the device this can be done\n"
		" by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal**\n"
		"\n"
		" As the type of signals that a device can send to a digital output depends heavily on the device and even on the\n"
		" digital output as well, this function will return a list of strings and a numerical representation for each signal\n"
		" that can be sent to this digital output.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalValue** and\n"
		" **OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalString** and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		":type sequence: mvIMPACT::acquire::TDigitalSignalTranslationDict\n"
		":param sequence: [out] A reference to a vector that will receive the list of allowed digital signals for this particular digital output pin.\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalCount", _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalCount, METH_VARARGS, "\n"
		" Returns the number of signals that can be used for pass through signal definitions for a certain digital output pin of this device.\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue", _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue, METH_VARARGS, "\n"
		" Receives a valid signal that can be passed directly to a certain digital output pin.\n"
		" Whenever it is necessary to output a certain signal (e.g. a digital input signal connected to the device or\n"
		" an internal digital signal like e.g. a frame valid signal) to a digital output of the device this can be done\n"
		" by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal**\n"
		"\n"
		" As the type of signals that a device can send to a digital output depends heavily on the device and even on the\n"
		" digital output as well, this function together with the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalString**\n"
		" can be used to query a list of strings and a numerical representation for each signal\n"
		" that can be sent to this digital output.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" C++ offers the more efficient function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**\n"
		" to obtain this information.\n"
		" }\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property. The find out the last valid value for this parameter call **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalCount**\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString", _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString, METH_VARARGS, "\n"
		" Receives a valid string representation of a signal that can be passed directly to a certain digital output pin.\n"
		" Whenever it is necessary to output a certain signal (e.g. a digital input signal connected to the device or\n"
		" an internal digital signal like e.g. a frame valid signal) to a digital output of the device this can be done\n"
		" by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal**\n"
		"\n"
		" As the type of signals that a device can send to a digital output depends heavily on the device and even on the\n"
		" digital output as well, this function together with the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalString**\n"
		" can be used to query a list of strings and a numerical representation for each signal\n"
		" that can be sent to this digital output.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" C++ offers the more efficient function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**\n"
		" to obtain this information.\n"
		" }\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property. The find out the last valid value for this parameter call **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalCount**\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_definePassThroughSignal", _wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Assigns a certain signal to a digital output.\n"
		" Some digital input signals or even some internal signals can be passed directly to one or more\n"
		" digital outputs.\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		":type digitalSignal: int\n"
		":param digitalSignal: [in] The digital signal that shall be passed to the digital output. Valid values for this parameter will be obtained by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**.\n"
		":type boInverted: boolean\n"
		":param boInverted: [in] If set to *true*, the signal will be inverted internally before being passed to the output.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Assigning a certain signal to a digital output.\n"
		" Some digital input signals or even some internal signals can be passed directly to one or more\n"
		" digital outputs.\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		":type digitalSignal: string\n"
		":param digitalSignal: [in] The string representation of the digital output that shall be passed to the digital output. Valid values for this parameter will be obtained by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**.\n"
		":type boInverted: boolean\n"
		":param boInverted: [in] If set to *true*, the signal will be inverted internally before being passed to the output.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Assigning a certain signal to a digital output.\n"
		" Some digital input signals or even some internal signals can be passed directly to one or more\n"
		" digital outputs.\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		":type digitalSignal: string\n"
		":param digitalSignal: [in] The string representation of the digital output that shall be passed to the digital output. Valid values for this parameter will be obtained by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**.\n"
		":param boInverted: [in] If set to *true*, the signal will be inverted internally before being passed to the output.\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_undefineSignal", _wrap_OutputSignalGeneratorFrameGrabber_undefineSignal, METH_VARARGS, "\n"
		" Removes the signal definition from the specified output pin.\n"
		" Whenever a signal has been defined for a a certain digital output\n"
		" pin, this pin can no longer controlled using the corresponding functions\n"
		" in the class **mvIMPACT::acquire::DigitalOutput**. This function removes the\n"
		" signal definition and hands back manual control of that digital output to the user.\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_defineLineScanPulse", _wrap_OutputSignalGeneratorFrameGrabber_defineLineScanPulse, METH_VARARGS, "\n"
		" Defines a pulse to trigger line scan cameras.\n"
		" Calling this function without setting **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::controlMode**\n"
		" to **mvIMPACT::acquire::docmRTC** will have **NO** effect.\n"
		"\n"
		" Notes: \n"
		" Not every frame grabber will offer the **mvIMPACT::acquire::docmRTC**\n"
		" mode. Check is the mode is available by reading the properties translation dictionary with\n"
		" the functions **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDictValue**. The detailed description\n"
		" of this class might contain source code examples for the language you are working with.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" C++ offers the more efficient function **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDict**\n"
		" in addition to the functions mentioned above.\n"
		" }\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::undefineSignal**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pOutput: :py:class:`DigitalOutput`\n"
		":param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.\n"
		":type pulseStartEventValue: int\n"
		":param pulseStartEventValue: [in] Defines the start event for the signal generation. Valid values for this parameter are defined by **mvIMPACT::acquire::TDeviceSignalOutputStartEvent**.\n"
		":type softwareSignalPeriod_pclk: int\n"
		":param softwareSignalPeriod_pclk: [in] Defines the frequency for a continuously generated signal if *pulseStartEventValue* is **mvIMPACT::acquire::dsoseSyncInRisingEdge** or **mvIMPACT::acquire::dsoseSyncInFallingEdge** and is ignored otherwise.\n"
		":type width_pclk: int\n"
		":param width_pclk: [in] The width of the signal to generate if *pulseStartEventValue* is **mvIMPACT::acquire::dsoseSyncInRisingEdge**, **mvIMPACT::acquire::dsosePeriodically** or **mvIMPACT::acquire::dsoseSyncInFallingEdge** and is ignored otherwise.\n"
		":type polarity: int\n"
		":param polarity: [in] The polarity of the signal to generate if *pulseStartEventValue* is **mvIMPACT::acquire::dsoseSyncInRisingEdge**, **mvIMPACT::acquire::dsosePeriodically** or **mvIMPACT::acquire::dsoseSyncInFallingEdge** and is ignored otherwise. - 0: The signal will be low for *width_pclk* and high otherwise - 1: The signal will be high for *width_pclk* and high otherwise\n"
		":type divider: int\n"
		":param divider: [in] Defines the divider value if *pulseStartEventValue* is **mvIMPACT::acquire::dsosePeriodically**\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_controlMode_get", _wrap_OutputSignalGeneratorFrameGrabber_controlMode_get, METH_O, "\n"
		"An enumerated integer property defining the general method used to create output signals.\n"
		"This setting always applies to every signal defined. Modifying this property will also\n"
		"change the behaviour of signals already defined.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigitalOutputControlMode**.\n"
		"\n"
		"When switching to **mvIMPACT::acquire::docmRTC** mode\n"
		"only one signal can be created currently.\n"
		"\n"
		"Notes: \n"
		"Not every frame grabber will offer the **mvIMPACT::acquire::docmRTC**\n"
		"mode. Check if the mode is available by reading the properties translation dictionary with\n"
		"the functions **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDictValue**.\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		"\n"
		"Some devices will offer a more flexible way to define this behaviour. In this case, this property won't be available (a call to the function\n"
		"**mvIMPACT::acquire::Component::isValid** will return false). However then calls to **mvIMPACT::acquire::IOSubSystem::getPulseStartConfigurationCount**\n"
		"and **mvIMPACT::acquire::IOSubSystem::getPulseStartConfiguration** will succeed and the objects returned by\n"
		"**mvIMPACT::acquire::IOSubSystem::getPulseStartConfiguration** (**mvIMPACT::acquire::PulseStartConfiguration)** will\n"
		"provide a more sophisticated way to define the signal output behaviour of a device.\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_pulseStartEvent_get", _wrap_OutputSignalGeneratorFrameGrabber_pulseStartEvent_get, METH_O, "\n"
		"An enumerated integer property defining the general behaviour of created output signals.\n"
		"This setting always applies to every signal defined. Modifying this property will also\n"
		"change the behaviour of signals already defined.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceSignalOutputStartEvent**.\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_imageTrigger_get", _wrap_OutputSignalGeneratorFrameGrabber_imageTrigger_get, METH_O, "\n"
		"An enumerated integer property defining the general behaviour of created output signals.\n"
		"This setting always applies to every signal defined. Modifying this property will also\n"
		"change the behaviour of signals already defined.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceImageTrigger**.\n"
		""},
	 { "OutputSignalGeneratorFrameGrabber_swigregister", OutputSignalGeneratorFrameGrabber_swigregister, METH_O, NULL},
	 { "OutputSignalGeneratorFrameGrabber_swiginit", OutputSignalGeneratorFrameGrabber_swiginit, METH_VARARGS, NULL},
	 { "new_Connector", _wrap_new_Connector, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::Connector** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "Connector_cameraOutputUsed_get", _wrap_Connector_cameraOutputUsed_get, METH_O, "\n"
		"An enumerated integer property defining the video signal output of the video signal source used for the connection to the video signal sink.\n"
		"Notes: \n"
		"Not every video signal sink will support every possible value defined for this property.\n"
		"For example a CameraLink(R) frame grabber will not offer to use an SVideo connector.\n"
		"Therefore the translation dictionary of this property should be used to find out, which connector types are available.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraOutput**.\n"
		"\n"
		"\n"
		"This property might not be supported by every device. Therefore always call the function\n"
		"**mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "Connector_videoChannel_get", _wrap_Connector_videoChannel_get, METH_O, "\n"
		"An integer property containing the video channel the camera belonging to the current setting is connected to.\n"
		"The maximum possible video channel might change when the property\n"
		"**mvIMPACT::acquire::Connector::cameraOutputUsed** is modified as the different\n"
		"ways to transmit a video signal require more or less video input channels. While e.g. a composite\n"
		"video signal can be transmitted via a single wire, an RGB signal requires either 3 or 4 wires\n"
		"(depending on whether the sync. signal is transmitted on a separate wire or not).\n"
		"\n"
		"The first channel will always have the number 0. The limits (max/min values) can be queried\n"
		"by calling the function **mvIMPACT::acquire::PropertyI::getMinValue** or\n"
		"**mvIMPACT::acquire::PropertyI::getMaxValue**.\n"
		"\n"
		"Notes: \n"
		"This property might not be supported by every device. Therefore always call the function\n"
		"**mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "Connector_pinDescription_get", _wrap_Connector_pinDescription_get, METH_O, "\n"
		"A string property **(read-only)** containing a description for the video channel currently selected by the property **mvIMPACT::acquire::Connector::videoChannel**.\n"
		"The description string contains information about the connector pins belonging to this video\n"
		"input of the video signal sink as well as the corresponding name of this video input.\n"
		"\n"
		"Notes: \n"
		"This property might not be supported by every device. Therefore always call the function\n"
		"**mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "delete_Connector", _wrap_delete_Connector, METH_O, NULL},
	 { "Connector_swigregister", Connector_swigregister, METH_O, NULL},
	 { "Connector_swiginit", Connector_swiginit, METH_VARARGS, NULL},
	 { "new_BasicDeviceSettingsWithAOI", _wrap_new_BasicDeviceSettingsWithAOI, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::BasicDeviceSettingsWithAOI** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "BasicDeviceSettingsWithAOI_aoiHeight_get", _wrap_BasicDeviceSettingsWithAOI_aoiHeight_get, METH_O, " An integer property defining the number of lines to capture."},
	 { "BasicDeviceSettingsWithAOI_aoiStartX_get", _wrap_BasicDeviceSettingsWithAOI_aoiStartX_get, METH_O, "\n"
		"An integer property defining the X-offset for each capture line.\n"
		"Example: When setting this property to 5 the first pixel in each line of\n"
		"the resulting image will be pixel number 5 of each line transmitted by\n"
		"the camera.\n"
		""},
	 { "BasicDeviceSettingsWithAOI_aoiStartY_get", _wrap_BasicDeviceSettingsWithAOI_aoiStartY_get, METH_O, "\n"
		"An integer property defining the Y-offset.\n"
		"Example: When setting this property to 5 the first line of\n"
		"the resulting image will be line number 5 of the image transmitted by\n"
		"the camera.\n"
		""},
	 { "BasicDeviceSettingsWithAOI_aoiWidth_get", _wrap_BasicDeviceSettingsWithAOI_aoiWidth_get, METH_O, " An integer property defining the number of pixels to capture per line."},
	 { "delete_BasicDeviceSettingsWithAOI", _wrap_delete_BasicDeviceSettingsWithAOI, METH_O, NULL},
	 { "BasicDeviceSettingsWithAOI_swigregister", BasicDeviceSettingsWithAOI_swigregister, METH_O, NULL},
	 { "BasicDeviceSettingsWithAOI_swiginit", BasicDeviceSettingsWithAOI_swiginit, METH_VARARGS, NULL},
	 { "new_CameraSettingsBase", _wrap_new_CameraSettingsBase, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::CameraSettingsBase** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "CameraSettingsBase_pixelFormat_get", _wrap_CameraSettingsBase_pixelFormat_get, METH_O, "\n"
		"An enumerated integer property defining the pixel format used to transfer the image data into the target systems host memory.\n"
		"Support for this property has been added in version 1.11.0 of mvIMPACT Acquire thus old driver versions will\n"
		"raise an exception if an application accesses the property without checking if the property is present.\n"
		"\n"
		"By default this property will be set to **mvIMPACT::acquire::ibpfAuto**. This will result in the previous driver\n"
		"behaviour where depending on the various post processing steps that are enabled or disabled the driver will decide\n"
		"which transfer format will be used. However sometimes this could result in a transfer format, which is not ideal\n"
		"for the application (e.g. when a post processing step of the application needs RGBx888Packed but the systems bandwidth\n"
		"is limited the application might want to transfer the data in YUV422 packed and then use the fast format conversion\n"
		"algorithm in the driver). This can be achieved by explicitly setting **mvIMPACT::acquire::CameraSettingsBase::pixelFormat** to\n"
		"**mvIMPACT::acquire::ibpfYUV422Packed** and **mvIMPACT::acquire::ImageDestination::pixelFormat** to\n"
		"**mvIMPACT::acquire::ibpfRGBx888Packed**.\n"
		"\n"
		"Notes: \n"
		"Selecting a defined transfer format can in some cases result in certain filters (e.g. dark current, ...) to be switched\n"
		"of as then the filters themselves can no longer influence the transfer format, which is sometimes necessary as not every\n"
		"filter does support every input format. Also this property will contain only pixel formats, which are actually supported\n"
		"by the capture device, thus in most of the cases this will be a subset of the pixel formats defined by the enumeration defining this property.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageBufferPixelFormat**.\n"
		""},
	 { "delete_CameraSettingsBase", _wrap_delete_CameraSettingsBase, METH_O, NULL},
	 { "CameraSettingsBase_swigregister", CameraSettingsBase_swigregister, METH_O, NULL},
	 { "CameraSettingsBase_swiginit", CameraSettingsBase_swiginit, METH_VARARGS, NULL},
	 { "new_CameraSettingsVirtualDevice", _wrap_new_CameraSettingsVirtualDevice, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::CameraSettingsVirtualDevice** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "CameraSettingsVirtualDevice_bufferPartCount_get", _wrap_CameraSettingsVirtualDevice_bufferPartCount_get, METH_O, "\n"
		"An integer property defining the number of buffer part to transmit in each request.\n"
		"This property is meant to test the multi-part buffer feature of mvIMPACT Acquire mainly. When\n"
		"set to 0 multi-part buffer handling is switched off. When set to a value greater than 0 the\n"
		"virtual device will transmit data in multi-part mode, meaning that **mvIMPACT::acquire::Request::getBufferPartCount()**\n"
		"will return a value larger than zero. Only when this is the case the properties belonging to the\n"
		"individual buffer parts are guaranteed to contain up to date data while then all properties whose name\n"
		"starts with ``image`` within that request might not.\n"
		"\n"
		"Since: 2.20.0\n"
		""},
	 { "CameraSettingsVirtualDevice_aoiMode_get", _wrap_CameraSettingsVirtualDevice_aoiMode_get, METH_O, "\n"
		"An enumerated integer property defining the used AOI mode for the image capture.\n"
		"This feature will only be visible, when the property **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode**\n"
		"is set to **mvIMPACT::acquire::vdtmImageDirectory**. Then this property will allow to enforce a certain image dimension\n"
		"( **mvIMPACT::acquire::camUser** ) or to capture every image file in its original dimensions ( **mvIMPACT::acquire::camFull** ).\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraAoiMode**.\n"
		"\n"
		"Since: 2.11.9\n"
		""},
	 { "CameraSettingsVirtualDevice_gain_dB_get", _wrap_CameraSettingsVirtualDevice_gain_dB_get, METH_O, "\n"
		" A float property defining the gain in dB to be applied to the test image.\n"
		"The formula for given ``gain_dB`` is\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    gain_x= 10 ^ (gain_dB/20)\n"
		"\n"
		"**Example**:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    gain_x = 10 ^ (6/20) = 1.995\n"
		"\n"
		"I.e. increasing the gain setting by 6dB corresponds to factor of 2.\n"
		"\n"
		"The formula for given gain_x is\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    gain_dB = 20*log(gain_x) dB\n"
		"\n"
		"Where:\n"
		"\n"
		"``gain_dB``: MATRIX VISION gain value (logarithmic)\n"
		"\n"
		"``gain_x``: multiplicative gain\n"
		"\n"
		"``^``: power function\n"
		""},
	 { "CameraSettingsVirtualDevice_testMode_get", _wrap_CameraSettingsVirtualDevice_testMode_get, METH_O, "\n"
		"An enumerated integer property defining the test mode use to generate the dummy images.\n"
		"When **mvIMPACT::acquire::CameraSettingsBase::pixelFormat** is **NOT** set to **mvIMPACT::acquire::ibpfAuto**, this\n"
		"this property will become invisible.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TVirtualDeviceTestMode**.\n"
		""},
	 { "CameraSettingsVirtualDevice_channelBitDepth_get", _wrap_CameraSettingsVirtualDevice_channelBitDepth_get, METH_O, "\n"
		"An integer property defining the channel bit depth for certain test image generation modes.\n"
		"When **mvIMPACT::acquire::CameraSettingsBase::pixelFormat** is **NOT** set to **mvIMPACT::acquire::ibpfAuto**, this\n"
		"this property will become invisible.\n"
		"\n"
		"When **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode** is set to **mvIMPACT::acquire::vdtmMovingMonoRamp**,\n"
		"**mvIMPACT::acquire::vdtmMovingBayerDataRamp** or **mvIMPACT::acquire::vdtmBayerWhiteBalanceTestImage** this property\n"
		"will allow to define the pixel format for the test image.\n"
		""},
	 { "CameraSettingsVirtualDevice_paddingX_get", _wrap_CameraSettingsVirtualDevice_paddingX_get, METH_O, "\n"
		"An integer property defining the padding(in bytes) in X-direction for certain test image generation modes.\n"
		"When **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode** is set to a mono format(not the weird packed ones!),\n"
		"**mvIMPACT::acquire::vdtmMovingBayerDataRamp** or **mvIMPACT::acquire::vdtmBayerWhiteBalanceTestImage** this property\n"
		"will allow to define the padding in bytes for each line. This will result in images where the line pitch differs from\n"
		"the width multiplied by the bytes per pixel value. E.g. a padding of 1 in X-direction and a width of 5 for a 16 bit mono\n"
		"format will result in a line pitch of 11 bytes(5*2 + 1).\n"
		""},
	 { "CameraSettingsVirtualDevice_tapsXGeometry_get", _wrap_CameraSettingsVirtualDevice_tapsXGeometry_get, METH_O, "\n"
		" An enumerated integer property defining the way this camera transmits the pixel data in X direction.\n"
		" Within the virtual device driver, modifying this property internally will only attach the corresponding\n"
		" attribute to the request buffer, thus might result in the tap sort filter to process the data. This is mainly\n"
		" meant for testing purposes.\n"
		"\n"
		" Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTapsXGeometry**.\n"
		"Since: 2.5.2\n"
		""},
	 { "CameraSettingsVirtualDevice_tapsYGeometry_get", _wrap_CameraSettingsVirtualDevice_tapsYGeometry_get, METH_O, "\n"
		" An enumerated integer property defining the way this camera transmits the pixel data in Y direction.\n"
		" Within the virtual device driver, modifying this property internally will only attach the corresponding\n"
		" attribute to the request buffer, thus might result in the tap sort filter to process the data. This is mainly\n"
		" meant for testing purposes.\n"
		"\n"
		" Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTapsYGeometry**.\n"
		"Since: 2.5.2\n"
		""},
	 { "CameraSettingsVirtualDevice_frameDelay_us_get", _wrap_CameraSettingsVirtualDevice_frameDelay_us_get, METH_O, " An integer property defining a delay in us before the 'captured' image is returned to the user."},
	 { "CameraSettingsVirtualDevice_imageDirectory_get", _wrap_CameraSettingsVirtualDevice_imageDirectory_get, METH_O, "\n"
		"A string property defining the directory to capture images from.\n"
		"This feature will only be visible, when the property **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode**\n"
		"is set to **mvIMPACT::acquire::vdtmImageDirectory**.\n"
		"\n"
		"See **mvIMPACT::acquire::CameraSettingsVirtualDevice::imageType** to find out how to configure what kind of images shall be captured from disc.\n"
		""},
	 { "CameraSettingsVirtualDevice_imageType_get", _wrap_CameraSettingsVirtualDevice_imageType_get, METH_O, "\n"
		"An enumerated integer property defining what images shall be captured from hard disk.\n"
		"This feature will only be visible, when the property **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode**\n"
		"is set to **mvIMPACT::acquire::vdtmImageDirectory**.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TVirtualDeviceImageType**.\n"
		""},
	 { "CameraSettingsVirtualDevice_bayerMosaicParity_get", _wrap_CameraSettingsVirtualDevice_bayerMosaicParity_get, METH_O, "\n"
		"An enumerated integer property defining the Bayer attribute assigned to the generated test image.\n"
		"When images are acquired via a directory, or a Bayer test pattern is generated this can be used to specify the Bayer parity.\n"
		"**mvIMPACT::acquire::bmpUndefined** will set the buffers Bayer attribute thus will result in a grey(mono) buffer being returned.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.\n"
		""},
	 { "CameraSettingsVirtualDevice_testImageBarWidth_get", _wrap_CameraSettingsVirtualDevice_testImageBarWidth_get, METH_O, " An integer property defining the width (in pixels) of the different bars in certain test modes."},
	 { "CameraSettingsVirtualDevice_userData_get", _wrap_CameraSettingsVirtualDevice_userData_get, METH_O, "\n"
		"A string property that will be copied into the user data property of each request.\n"
		"This e.g. can be used to assign a certain identifier to each image request.\n"
		""},
	 { "delete_CameraSettingsVirtualDevice", _wrap_delete_CameraSettingsVirtualDevice, METH_O, NULL},
	 { "CameraSettingsVirtualDevice_swigregister", CameraSettingsVirtualDevice_swigregister, METH_O, NULL},
	 { "CameraSettingsVirtualDevice_swiginit", CameraSettingsVirtualDevice_swiginit, METH_VARARGS, NULL},
	 { "new_CameraSettingsV4L2Device", _wrap_new_CameraSettingsV4L2Device, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::CameraSettingsV4L2Device** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "CameraSettingsV4L2Device_getCustomFeatureIterator", _wrap_CameraSettingsV4L2Device_getCustomFeatureIterator, METH_O, "\n"
		" Returns an iterator to for iterating inside a device specific feature list.\n"
		" This can be useful a device offers custom features that are not defined in the V4L2 standard and thus\n"
		" can't be known at compile time.\n"
		"\n"
		" It allows to write code like this:\n"
		"\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     CameraSettingsV4L2Device cs( getDevicePointerFromSomewhere() );\n"
		"     Component it( cs.getCustomFeatureIterator() );\n"
		"     std::mapstd::string, std::string m;\n"
		"     while( it.isValid() )\n"
		"     {\n"
		"       // collect all entries that are properties and store their current name and value in a map\n"
		"       if( it.isProp()  it.isVisible() )\n"
		"       {\n"
		"         Property prop( it );\n"
		"         m.insert( std::make_pair( prop.name(), prop.readS() );\n"
		"       }\n"
		"       ++it;\n"
		"     }\n"
		"}Else if: DOXYGEN_JAVA_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     import java.util.Hashtable;\n"
		"\n"
		"     // ...\n"
		"\n"
		"     CameraSettingsV4L2Device cs = new CameraSettingsV4L2Device( getDevicePointerFromSomewhere() );\n"
		"     Component it = cs.getCustomFeatureIterator();\n"
		"     HashtableString, String m = new HashtableString, String();\n"
		"     while( it.isValid() )\n"
		"     {\n"
		"       // collect all entries that are properties and store their current name and value in a hash table\n"
		"       if( it.isProp()  it.isVisible() )\n"
		"       {\n"
		"          Property prop = new Property( it.hObj() );\n"
		"          m.put( prop.name(), prop.readS() );\n"
		"       }\n"
		"       it = it.nextSibling();\n"
		"     }\n"
		"}Else if: DOXYGEN_PYTHON_DOCUMENTATION {\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"      cs = acquire.CameraSettingsV4L2Device(pDev)\n"
		"      it = acquire.Component(cs.getCustomFeatureIterator())\n"
		"      m = {}\n"
		"      while it.isValid:\n"
		"        # collect all entries that are properties and store their current name and value in a map\n"
		"        if it.isProp and it.isVisible:\n"
		"          prop = acquire.Property(it);\n"
		"          m[prop.name()] = prop.readS()\n"
		"        it = it.nextSibling()\n"
		"}\n"
		""},
	 { "CameraSettingsV4L2Device_imageWidth_get", _wrap_CameraSettingsV4L2Device_imageWidth_get, METH_O, "\n"
		"An integer property defining the width of the image supplied by the V4L2 device.\n"
		"See also: V4L2 API at http://v4l2spec.bytesex.org/spec-single/v4l2.html\n"
		""},
	 { "CameraSettingsV4L2Device_imageHeight_get", _wrap_CameraSettingsV4L2Device_imageHeight_get, METH_O, "\n"
		"An integer property defining the height of the image supplied by the V4L2 device.\n"
		"See also: V4L2 API at http://v4l2spec.bytesex.org/spec-single/v4l2.html\n"
		""},
	 { "CameraSettingsV4L2Device_videoStandard_get", _wrap_CameraSettingsV4L2Device_videoStandard_get, METH_O, "\n"
		"An integer property defining the video standard.\n"
		"Use this property to configure the V4L2-device corresponding to the connected video source.\n"
		"Available video standards depend on the V4L2-device and conform to **v4l2_std_id**\n"
		"See also: V4L2 API at http://v4l2spec.bytesex.org/spec-single/v4l2.html\n"
		""},
	 { "CameraSettingsV4L2Device_pixelFormat_get", _wrap_CameraSettingsV4L2Device_pixelFormat_get, METH_O, "\n"
		"An integer property defining the pixel format of captured frames.\n"
		"Use this property to set the pixel format within the image buffer supplied by the V4L2-device.\n"
		"Available pixel formats depend on the V4L2-device and conform to **v4l2_fourcc()**\n"
		"See also: V4L2 API at http://v4l2spec.bytesex.org/spec-single/v4l2.html\n"
		""},
	 { "CameraSettingsV4L2Device_brightness_get", _wrap_CameraSettingsV4L2Device_brightness_get, METH_O, "\n"
		"An integer property to adjust the brightness.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_contrast_get", _wrap_CameraSettingsV4L2Device_contrast_get, METH_O, "\n"
		"An integer property to adjust the contrast.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_saturation_get", _wrap_CameraSettingsV4L2Device_saturation_get, METH_O, "\n"
		"An integer property to adjust the saturation.\n"
		"This property represents a V4L2-control ID.\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_hue_get", _wrap_CameraSettingsV4L2Device_hue_get, METH_O, "\n"
		"An integer property to adjust the hue.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_blackLevel_get", _wrap_CameraSettingsV4L2Device_blackLevel_get, METH_O, "\n"
		"An integer property to adjust the black level.\n"
		"This property represents a V4L2-control ID.\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_autoWhiteBalance_get", _wrap_CameraSettingsV4L2Device_autoWhiteBalance_get, METH_O, "\n"
		"An enumerated integer property to switch on/off the auto white balance function of the V4L2-device.\n"
		"This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsV4L2Device_redBalance_get", _wrap_CameraSettingsV4L2Device_redBalance_get, METH_O, "\n"
		"An integer property to adjust the red balance.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_blueBalance_get", _wrap_CameraSettingsV4L2Device_blueBalance_get, METH_O, "\n"
		"An integer property to adjust the blue balance.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_gamma_get", _wrap_CameraSettingsV4L2Device_gamma_get, METH_O, "\n"
		"An integer property to adjust the gamma.\n"
		"This property represents a V4L2-control ID\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a min-value, a max-value and step-width are defined. Thus, invalid values may be tuned after writing to fit within the limits.\n"
		""},
	 { "CameraSettingsV4L2Device_exposure_get", _wrap_CameraSettingsV4L2Device_exposure_get, METH_O, "\n"
		"An integer property to adjust the exposure.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_autoGain_get", _wrap_CameraSettingsV4L2Device_autoGain_get, METH_O, "\n"
		"An enumerated integer property to switch on/off the auto gain.\n"
		"This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsV4L2Device_gain_get", _wrap_CameraSettingsV4L2Device_gain_get, METH_O, "\n"
		"An integer property to adjust the gain.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_HFlip_get", _wrap_CameraSettingsV4L2Device_HFlip_get, METH_O, "\n"
		"An enumerated integer property to mirror the frames horizontally.\n"
		"This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsV4L2Device_VFlip_get", _wrap_CameraSettingsV4L2Device_VFlip_get, METH_O, "\n"
		"An integer property to mirror the frames vertically.\n"
		"This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsV4L2Device_powerLineFrequency_get", _wrap_CameraSettingsV4L2Device_powerLineFrequency_get, METH_O, "\n"
		"An enumerated integer property to enable power line frequency filter.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"\n"
		"If supported, possible values conform to V4L2 API:\n"
		"\n"
		"|string representation|numerical representation|\n"
		"|V4L2_CID_POWER_LINE_FREQUENCY_DISABLED|0|\n"
		"|V4L2_CID_POWER_LINE_FREQUENCY_50HZ|1|\n"
		"|V4L2_CID_POWER_LINE_FREQUENCY_60HZ|2|\n"
		""},
	 { "CameraSettingsV4L2Device_hueAuto_get", _wrap_CameraSettingsV4L2Device_hueAuto_get, METH_O, "\n"
		"An enumerated integer property to switch on/off auto hue.\n"
		"This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsV4L2Device_whiteBalanceTemperature_get", _wrap_CameraSettingsV4L2Device_whiteBalanceTemperature_get, METH_O, "\n"
		"An integer property to adjust white balance temperature.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_sharpness_get", _wrap_CameraSettingsV4L2Device_sharpness_get, METH_O, "\n"
		"An integer property to adjust the sharpness.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "CameraSettingsV4L2Device_backlightCompensation_get", _wrap_CameraSettingsV4L2Device_backlightCompensation_get, METH_O, "\n"
		"An integer property to adjust the backlight compensation.\n"
		"This property represents a V4L2-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a min-value, a max-value and step-width are defined. Thus, invalid values may be tuned after writing to fit within the limits.\n"
		""},
	 { "delete_CameraSettingsV4L2Device", _wrap_delete_CameraSettingsV4L2Device, METH_O, NULL},
	 { "CameraSettingsV4L2Device_swigregister", CameraSettingsV4L2Device_swigregister, METH_O, NULL},
	 { "CameraSettingsV4L2Device_swiginit", CameraSettingsV4L2Device_swiginit, METH_VARARGS, NULL},
	 { "AutoControlParameters_getIsAvailable", _wrap_AutoControlParameters_getIsAvailable, METH_O, "\n"
		"This function should be called to check if this device offers auto control parameters.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the device offers the features defined by this object.\n"
		"    - false otherwise\n"
		""},
	 { "AutoControlParameters_aoiHeight_get", _wrap_AutoControlParameters_aoiHeight_get, METH_O, " An integer property defining the height of the rectangle used for the parameter calculation."},
	 { "AutoControlParameters_aoiStartX_get", _wrap_AutoControlParameters_aoiStartX_get, METH_O, "\n"
		"An integer property defining the X-offset of the rectangle used for the parameter calculation.\n"
		"Example: When setting this property to 5 the first pixel in each line of\n"
		"the resulting rectangle used for the calculation will be pixel number 5\n"
		"of each line transmitted by the camera.\n"
		""},
	 { "AutoControlParameters_aoiStartY_get", _wrap_AutoControlParameters_aoiStartY_get, METH_O, "\n"
		"An integer property defining the Y-offset of the rectangle used for the parameter calculation.\n"
		"Example: When setting this property to 5 the first line of\n"
		"the resulting rectangle used for the calculation will be line number 5 of the\n"
		"image transmitted by the camera.\n"
		""},
	 { "AutoControlParameters_aoiWidth_get", _wrap_AutoControlParameters_aoiWidth_get, METH_O, " An integer property defining the width of the rectangle."},
	 { "AutoControlParameters_aoiMode_get", _wrap_AutoControlParameters_aoiMode_get, METH_O, "\n"
		"An enumerated integer property defining the which area of the image is used for the calculation of the parameters.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAoiMode**.\n"
		""},
	 { "AutoControlParameters_desiredAverageGreyValue_get", _wrap_AutoControlParameters_desiredAverageGreyValue_get, METH_O, "\n"
		"An integer property defining the average grey value to be reached within the AOI in the image by the control circuit.\n"
		"For multi-byte pixel formats like e.g. **mvIMPACT::acquire::ibpfMono10** this value will refer to\n"
		"the 8 most significant bits of the pixel data, thus e.g a value of 128 for this property will result\n"
		"it the controller trying reach an average grey value of 512 (0x200).\n"
		""},
	 { "AutoControlParameters_controllerSpeed_get", _wrap_AutoControlParameters_controllerSpeed_get, METH_O, "\n"
		"An enumerated integer property defining the speed the control circuit will be operated in.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoControlSpeed**.\n"
		"\n"
		"Once the controller started to react and adapt itself to a new situation, this property will\n"
		"define how long this adaption will take, while **AutoControlParameters::controllerDelay_Images**\n"
		"defines the number of images to wait from a detected change to the actual start of the\n"
		"adaption to this new situation.\n"
		""},
	 { "AutoControlParameters_controllerGain_get", _wrap_AutoControlParameters_controllerGain_get, METH_O, "\n"
		"The **P** fraction of the controller.\n"
		"This feature will only be visible when **mvIMPACT::acquire::AutoControlParameters::controllerSpeed**\n"
		"is set to **mvIMPACT::acquire::acsUserDefined**.\n"
		""},
	 { "AutoControlParameters_controllerIntegralTime_ms_get", _wrap_AutoControlParameters_controllerIntegralTime_ms_get, METH_O, "\n"
		"The **I** fraction of the controller.\n"
		"This feature will only be visible when **mvIMPACT::acquire::AutoControlParameters::controllerSpeed**\n"
		"is set to **mvIMPACT::acquire::acsUserDefined**.\n"
		""},
	 { "AutoControlParameters_controllerDerivativeTime_ms_get", _wrap_AutoControlParameters_controllerDerivativeTime_ms_get, METH_O, "\n"
		"The **D** fraction of the controller.\n"
		"This feature will only be visible when **mvIMPACT::acquire::AutoControlParameters::controllerSpeed**\n"
		"is set to **mvIMPACT::acquire::acsUserDefined**.\n"
		""},
	 { "AutoControlParameters_controllerDelay_Images_get", _wrap_AutoControlParameters_controllerDelay_Images_get, METH_O, "\n"
		"An integer property to influence the speed the AGC and/or AEC control circuit will react and adapt to changes.\n"
		"While **AutoControlParameters::controllerSpeed** influences the overall time\n"
		"needed to adjust the controller to a new situation, this property can be used to define a\n"
		"delay when the controller shall start to adapt to a changed situation.\n"
		""},
	 { "AutoControlParameters_gainLowerLimit_dB_get", _wrap_AutoControlParameters_gainLowerLimit_dB_get, METH_O, "\n"
		"A float property defining the lower limit for the cameras gain(in dB).\n"
		"When the AGC is active this value defines the minimum value for the cameras gain.\n"
		"Even if the controller can reach the desired average grey value, the gain will\n"
		"never fall below this value.\n"
		""},
	 { "AutoControlParameters_gainUpperLimit_dB_get", _wrap_AutoControlParameters_gainUpperLimit_dB_get, METH_O, "\n"
		"A float property defining the upper limit for the cameras gain(in dB).\n"
		"When the AGC is active this value defines the maximum value for the cameras gain.\n"
		"Even if the controller can reach the desired average grey value, the gain will\n"
		"never exceed this value.\n"
		""},
	 { "AutoControlParameters_exposeLowerLimit_us_get", _wrap_AutoControlParameters_exposeLowerLimit_us_get, METH_O, "\n"
		"A float property defining the lower limit for the sensors expose time(in us).\n"
		"When the AEC is active this value defines the minimum value for the sensors expose time(in us).\n"
		"Even if the controller can reach the desired average grey value, the expose time will\n"
		"never fall below this value.\n"
		""},
	 { "AutoControlParameters_exposeUpperLimit_us_get", _wrap_AutoControlParameters_exposeUpperLimit_us_get, METH_O, "\n"
		"An integer property defining the upper limit for the sensors expose time in us.\n"
		"When the AEC is active this value defines the maximum value for the sensors expose time(in us).\n"
		"Even if the controller can reach the desired average grey value, the expose time will\n"
		"never exceed this value.\n"
		""},
	 { "delete_AutoControlParameters", _wrap_delete_AutoControlParameters, METH_O, NULL},
	 { "AutoControlParameters_swigregister", AutoControlParameters_swigregister, METH_O, NULL},
	 { "new_CameraSettingsBlueDevice", _wrap_new_CameraSettingsBlueDevice, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::CameraSettingsBlueDevice** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "CameraSettingsBlueDevice_autoControlMode_get", _wrap_CameraSettingsBlueDevice_autoControlMode_get, METH_O, "\n"
		"An enumerated integer property defining the auto control mode the device is operated in.\n"
		"This property can be used to control the overall behaviour of the algorithms used for performing AEC\n"
		"(**A** utomatic **E** xpose **C** ontrol) or AGC (**A** utomatic **G** ain **C** ontrol).\n"
		"This could be done by the device itself thus e.g. even in the analog domain or e.g. by a software\n"
		"process in the driver. Each method will offer certain advantages and disadvantages and depending on the\n"
		"application the correct method can be selected.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoControlMode**.\n"
		"\n"
		"Every device or even different models belonging to the same device family may support different auto control modes,\n"
		"thus it's crucial to query the valid modes for each device by reading the properties translation dictionary BEFORE trying\n"
		"to assign a certain value to this property.\n"
		""},
	 { "CameraSettingsBlueDevice_autoGainControl_get", _wrap_CameraSettingsBlueDevice_autoGainControl_get, METH_O, "\n"
		"An enumerated integer property, which represents the current mode the AGC (**A** utomatic **G** ain **C** ontrol) is operated in.\n"
		"The values used to capture the image, which are directly influenced by an activated AGC or AEC\n"
		"(e.g. the gain or the exposure time) will be returned as part of the result of the\n"
		"image request.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoGainControl**.\n"
		"\n"
		"Notes: \n"
		"This property is not supported by every device. Therefore always call the function\n"
		"**mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsBlueDevice_autoExposeControl_get", _wrap_CameraSettingsBlueDevice_autoExposeControl_get, METH_O, "\n"
		"An enumerated integer property, which represents the current mode the AEC (**A** utomatic **E** xpose **C** ontrol) is operated in.\n"
		"The values used to capture the image, which are directly influenced by an activated AGC or AEC\n"
		"(e.g. the gain or the exposure time) will be returned as part of the result of the\n"
		"image request.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoExposureControl**.\n"
		"\n"
		"Notes: \n"
		"This property might not be supported by every device. Therefore always call the function\n"
		"**mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsBlueDevice_gain_dB_get", _wrap_CameraSettingsBlueDevice_gain_dB_get, METH_O, "\n"
		" A float property defining the gain in dB.\n"
		"The formula for given ``gain_dB`` is\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    gain_x= 10 ^ (gain_dB/20)\n"
		"\n"
		"**Example**:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    gain_x = 10 ^ (6/20) = 1.995\n"
		"\n"
		"I.e. increasing the gain setting by 6dB corresponds to factor of 2.\n"
		"\n"
		"The formula for given gain_x is\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    gain_dB = 20*log(gain_x) dB\n"
		"\n"
		"Where:\n"
		"\n"
		"``gain_dB``: MATRIX VISION gain value (logarithmic)\n"
		"\n"
		"``gain_x``: multiplicative gain\n"
		"\n"
		"``^``: power function\n"
		""},
	 { "CameraSettingsBlueDevice_offset_pc_get", _wrap_CameraSettingsBlueDevice_offset_pc_get, METH_O, "\n"
		"A float property defining the analogue sensor offset in percent of the allowed range (sensor specific).\n"
		"This property influences the average grey level when no light reaches the sensor.\n"
		"\n"
		"     **mvBlueFOX** **specific**:\n"
		"Changing its value will have no effect if **mvIMPACT::acquire::CameraSettingsBlueFOX::offsetAutoCalibration** is set to\n"
		"**mvIMPACT::acquire::aocOn**.\n"
		"\n"
		"By default\n"
		"this value will be around 10 (if **mvIMPACT::acquire::CameraSettingsBlueFOX::offsetAutoCalibration** if set\n"
		"to **mvIMPACT::acquire::aocOn)**. This means the average grey value for an image\n"
		"taken in a completely dark environment will be around 10. When setting\n"
		"**mvIMPACT::acquire::CameraSettingsBlueFOX::offsetAutoCalibration** to **mvIMPACT::acquire::aocOff**\n"
		"**mvIMPACT::acquire::CameraSettingsBlueFOX::offset_pc** can be used to modify this value.\n"
		"\n"
		"Image: Offset_pc.png\n"
		"The valid range for this property lies between -100% and +100%, whereas negative values\n"
		"will shifts the black level towards 0 and positive values to 255.\n"
		"\n"
		"Notes: \n"
		"This property might not be supported by every device. Therefore always call the function\n"
		"**mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsBlueDevice_pixelClock_KHz_get", _wrap_CameraSettingsBlueDevice_pixelClock_KHz_get, METH_O, "\n"
		"An enumerated integer property defining the pixel clock of the camera sensor in KHz.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraPixelClock**.\n"
		"\n"
		"Notes: \n"
		"Changing the pixel clock at runtime will have major impact on the overall behaviour of the\n"
		"camera. The pixel clock should therefore not be modified constantly during the execution\n"
		"of the application code. Whenever this property is changed, the next images captured should\n"
		"be skipped if a device works with an active auto offset calibration controller circuit as then the\n"
		"control circuits on the camera might need one to three images until all control loops are\n"
		"locked again.\n"
		"\n"
		"Every device or even different models belonging to the same device family may support different pixel clocks,\n"
		"thus it's crucial to query the valid clock modes for each sensor by reading the properties translation dictionary.\n"
		""},
	 { "CameraSettingsBlueDevice_exposeMode_get", _wrap_CameraSettingsBlueDevice_exposeMode_get, METH_O, "\n"
		"An enumerated integer property defining the exposure mode the camera sensor is operated in.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExposeMode**.\n"
		"\n"
		"Notes: \n"
		"Not every device will offer the same options.\n"
		"Check for valid modes by reading the properties translation dictionary with\n"
		"the functions **mvIMPACT::acquire::PropertyICameraExposeMode::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyICameraExposeMode::getTranslationDictValue**.\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraExposeMode::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		""},
	 { "CameraSettingsBlueDevice_expose_us_get", _wrap_CameraSettingsBlueDevice_expose_us_get, METH_O, "\n"
		"An integer property which defines the exposure time for an image in us.\n"
		"Image: Expose_us.png\n"
		""},
	 { "CameraSettingsBlueDevice_binningMode_get", _wrap_CameraSettingsBlueDevice_binningMode_get, METH_O, "\n"
		"An enumerated integer property defining the binning mode the camera is operated in.\n"
		"By default the no binning will be performed.\n"
		"Notes: \n"
		"Not every camera will support every binning mode. To find out which binning modes\n"
		"are supported by your camera you can query the properties translation table with\n"
		"the functions **mvIMPACT::acquire::PropertyICameraBinningMode::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyICameraBinningMode::getTranslationDictValue**\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraBinningMode::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraBinningMode**.\n"
		""},
	 { "CameraSettingsBlueDevice_testMode_get", _wrap_CameraSettingsBlueDevice_testMode_get, METH_O, "\n"
		" An enumerated integer property defining the image transmission mode of the camera.\n"
		"If this property is set to **mvIMPACT::acquire::ctmOff** the 'normal' image\n"
		"captured by the cameras sensor will be transmitted. This is the default.\n"
		"To ensure correct operation the camera might define several test modes where\n"
		"some kind of well defined pattern will be transmitted.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTestMode**. No every\n"
		"test mode will be supported by every device.\n"
		""},
	 { "CameraSettingsBlueDevice_triggerMode_get", _wrap_CameraSettingsBlueDevice_triggerMode_get, METH_O, "\n"
		"An enumerated integer property which defines what kind of trigger mode shall be used for an image acquisition.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTriggerMode**.\n"
		"\n"
		"Notes: \n"
		"Not every device will support every trigger mode. To find out which trigger modes are supported by a specific\n"
		"device at runtime the properties translation dictionary should be queried.\n"
		"\n"
		"\n"
		"Also the sensor specific part of this manual will contain a list of trigger modes that are available for\n"
		"this specific image sensor.\n"
		""},
	 { "CameraSettingsBlueDevice_frameDelay_us_get", _wrap_CameraSettingsBlueDevice_frameDelay_us_get, METH_O, "\n"
		"An integer property defining the delay in us between an external trigger event an the begin of the sensor exposure.\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsBlueDevice_autoControlParameters_get", _wrap_CameraSettingsBlueDevice_autoControlParameters_get, METH_O, "\n"
		"Provides access to the control parameters for AGC and AEC.\n"
		"Notes: \n"
		"These settings will only affect the image if **mvIMPACT::acquire::CameraSettingsBlueDevice::autoGainControl**,\n"
		"**mvIMPACT::acquire::CameraSettingsBlueDevice::autoExposeControl** or both are set to active.\n"
		""},
	 { "CameraSettingsBlueDevice_getAutoControlParameters", _wrap_CameraSettingsBlueDevice_getAutoControlParameters, METH_O, "\n"
		"Provides access to the control parameters for AGC and AEC.\n"
		"Notes: \n"
		"These settings will only affect the image if **mvIMPACT::acquire::CameraSettingsBlueDevice::autoGainControl**,\n"
		"**mvIMPACT::acquire::CameraSettingsBlueDevice::autoExposeControl** or both are set to active.\n"
		""},
	 { "delete_CameraSettingsBlueDevice", _wrap_delete_CameraSettingsBlueDevice, METH_O, NULL},
	 { "CameraSettingsBlueDevice_swigregister", CameraSettingsBlueDevice_swigregister, METH_O, NULL},
	 { "CameraSettingsBlueDevice_swiginit", CameraSettingsBlueDevice_swiginit, METH_VARARGS, NULL},
	 { "HDRKneePoint_HDRControlVoltage_mV_get", _wrap_HDRKneePoint_HDRControlVoltage_mV_get, METH_O, " An enumerated integer property that can be used to define the control voltage in mV for this knee point."},
	 { "HDRKneePoint_HDRExposure_ppm_get", _wrap_HDRKneePoint_HDRExposure_ppm_get, METH_O, " An enumerated integer property that can be used to define the exposure time in ppm of the overall exposure time for this knee point."},
	 { "delete_HDRKneePoint", _wrap_delete_HDRKneePoint, METH_O, NULL},
	 { "HDRKneePoint_swigregister", HDRKneePoint_swigregister, METH_O, NULL},
	 { "new_HDRControl", _wrap_new_HDRControl, METH_O, "\n"
		"Copy constructor.\n"
		"Creates a new object from an existing device object. Keep in mind that this new object\n"
		"will provide access to the very same hardware and therefore you might as well use the original\n"
		"reference. This constructor is only provided for internal reference counting to guarantee correct operation of the\n"
		"objects of this class under all platforms and languages.\n"
		""},
	 { "delete_HDRControl", _wrap_delete_HDRControl, METH_O, NULL},
	 { "HDRControl_getIsAvailable", _wrap_HDRControl_getIsAvailable, METH_O, "\n"
		"This function should be called to check if this device offers HDR (**H**igh **D**ynamic **R**ange) control parameters.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if the device offers the features defined by this object.\n"
		"    - false otherwise\n"
		""},
	 { "HDRControl_getHDRKneePoint", _wrap_HDRControl_getHDRKneePoint, METH_VARARGS, "\n"
		" Returns a reference to a set of user definable parameters to configure a HDR (**H**igh **D**ynamic **R**ange) knee point.\n"
		" Use the property **mvIMPACT::acquire::HDRControl::HDRKneePointCount** to find out how many knee points are available\n"
		" or to change the number of knee points.\n"
		"\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* is invalid(too large) an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" :rtype: :py:class:`HDRKneePoint`\n"
		" :return: A reference to a set of user definable parameters to configure a HDR (**H**igh **D**ynamic **R**ange) knee point.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the knee point to be returned\n"
		""},
	 { "HDRControl_HDREnable_get", _wrap_HDRControl_HDREnable_get, METH_O, "\n"
		"An enumerated integer property which can be used to enable/disable HDR (**H**igh **D**ynamic **R**ange) mode.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "HDRControl_HDRMode_get", _wrap_HDRControl_HDRMode_get, METH_O, "\n"
		"An enumerated integer property which can be used to configure the HDR (**H**igh **D**ynamic **R**ange) mode to work with.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraHDRMode**.\n"
		""},
	 { "HDRControl_HDRKneePointCount_get", _wrap_HDRControl_HDRKneePointCount_get, METH_O, " An integer property to define the number of knee points to work with when **mvIMPACT::acquire::HDRControl::HDRMode** is set to **mvIMPACT::acquire::cHDRmUser**."},
	 { "HDRControl_swigregister", HDRControl_swigregister, METH_O, NULL},
	 { "HDRControl_swiginit", HDRControl_swiginit, METH_VARARGS, NULL},
	 { "new_CameraSettingsBlueFOX", _wrap_new_CameraSettingsBlueFOX, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::CameraSettingsBlueFOX** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "CameraSettingsBlueFOX_getHDRControl", _wrap_CameraSettingsBlueFOX_getHDRControl, METH_O, " Returns the **mvIMPACT::acquire::HDRControl** object associated with this setting."},
	 { "CameraSettingsBlueFOX_offsetAutoCalibration_get", _wrap_CameraSettingsBlueFOX_offsetAutoCalibration_get, METH_O, "\n"
		"An enumerated integer property defining the offset calibration mode.\n"
		"If this property is set to **mvIMPACT::acquire::aocOff**\n"
		"the offset can be adjusted manually by modifying the **mvIMPACT::acquire::CameraSettingsBlueFOX::offset_pc** and\n"
		"mvIMPACT::acquire::CameraSettingsBlueFOX::offsetCorrection_pc properties.\n"
		"\n"
		"If set to **mvIMPACT::acquire::aocOn** the offset is approx. 10. That means,\n"
		"that the medium pixel count is 10, in case no light is falling on the sensor.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoOffsetCalibration**.\n"
		""},
	 { "CameraSettingsBlueFOX_offsetCorrection_pc_get", _wrap_CameraSettingsBlueFOX_offsetCorrection_pc_get, METH_O, "\n"
		"A float property defining and **additional** analogue sensor offset in percent of the allowed range (sensor specific) **per** **color** **channel**.\n"
		"Together with value of the property **mvIMPACT::acquire::CameraSettingsBlueDevice::offset_pc** this property influences the average grey level\n"
		"when no light reaches the sensor.\n"
		"\n"
		"This property stores 4 values.\n"
		"- The value at index 0 applies to the green component of the red-green rows of the bayer pattern\n"
		"- The value at index 1 applies to the red component of the bayer pattern\n"
		"- The value at index 2 applies to the green component of the blue-green rows of the bayer pattern\n"
		"- The value at index 3 applies to the blue component of the bayer pattern\n"
		"\n"
		"Notes: \n"
		"This property might not be supported by every device. Therefore always call the function\n"
		"**mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"In addition to that this property must be enabled explicitly by setting the advanced option bit\n"
		"**mvIMPACT::acquire::daoEnablePerChannelOffsetCorrection** of the property\n"
		"**mvIMPACT::acquire::CameraSettingsBlueFOX::advancedOptions**.\n"
		"See also: \n"
		"**mvIMPACT::acquire::CameraSettingsBlueDevice::offset_pc**\n"
		""},
	 { "CameraSettingsBlueFOX_offsetAutoBlackLevel_get", _wrap_CameraSettingsBlueFOX_offsetAutoBlackLevel_get, METH_O, "\n"
		"An integer property defining the digital value assumed as black.\n"
		"Modifying this property in rare cases might be useful to achieve a higher dynamic range for noise close to the black\n"
		"level.\n"
		"\n"
		"Notes: \n"
		"As the **mvBlueFOX** internally works with a 10 bit analog to digital conversion increasing this\n"
		"value by 4 will result in a black level increased by about 1 in the resulting 8 bit raw image\n"
		"delivered from the camera.\n"
		""},
	 { "CameraSettingsBlueFOX_offsetAutoBlackSpeed_get", _wrap_CameraSettingsBlueFOX_offsetAutoBlackSpeed_get, METH_O, "\n"
		"An enumerated integer property defining the speed of the auto offset calibration circuit.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed**.\n"
		""},
	 { "CameraSettingsBlueFOX_lineDelay_clk_get", _wrap_CameraSettingsBlueFOX_lineDelay_clk_get, METH_O, "\n"
		"An integer property defining the delay in clocks between two lines.\n"
		"Can be used to slow down the image readout the reduce the peak bandwidth required\n"
		"for the transfer.\n"
		""},
	 { "CameraSettingsBlueFOX_advancedOptions_get", _wrap_CameraSettingsBlueFOX_advancedOptions_get, METH_O, "\n"
		"An enumerated integer property defining a collection of advanced options that can be enabled or disabled.\n"
		"This property is highly sensor dependent. Each sensor might offer a different sub set of the options offered.\n"
		"Only experienced users should work with this feature.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceAdvancedOptions**.\n"
		""},
	 { "CameraSettingsBlueFOX_flashToExposeDelay_us_get", _wrap_CameraSettingsBlueFOX_flashToExposeDelay_us_get, METH_O, "\n"
		"An integer property defining the delay in us between the start of the flash signal output and the beginning of the expose period of the image sensor.\n"
		"Notes: \n"
		"This property is mainly provided for compatibility reasons. Previous versions of the\n"
		"**mvBlueFOX** driver produced a fixed delay of about 300 us between the beginning of the\n"
		"flash signal creation and the beginning of the sensors expose period. Newer versions of the\n"
		"driver do **NOT** produce this delay anymore which might cause a different illumination\n"
		"for applications using very intensive, short flash and expose times. Applications relying on\n"
		"the delay introduced in older driver versions should set this property to\n"
		"'300' by calling **mvIMPACT::acquire::PropertyI::write**.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::CameraSettingsBlueDevice::expose_us**\n"
		""},
	 { "CameraSettingsBlueFOX_flashMode_get", _wrap_CameraSettingsBlueFOX_flashMode_get, METH_O, "\n"
		"An enumerated integer property defining the behaviour of the flash output of the camera (if available).\n"
		"If this property is set the cameras flash output (if available) will be pulsed\n"
		"during the exposure period of the sensor. In that case the pulse width will be equal\n"
		"to the exposure time.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraFlashMode**.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::CameraSettingsBlueFOX::flashToExposeDelay_us**\n"
		""},
	 { "CameraSettingsBlueFOX_flashType_get", _wrap_CameraSettingsBlueFOX_flashType_get, METH_O, "\n"
		"An enumerated integer property defining the type of the flash output of the camera (if available).\n"
		"Depending of the camera sensor type (*rolling* shutter or *frame* *shutter*\n"
		"there well be different modes available\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraFlashType**.\n"
		""},
	 { "CameraSettingsBlueFOX_shutterMode_get", _wrap_CameraSettingsBlueFOX_shutterMode_get, METH_O, "\n"
		"An enumerated integer property defining the shutter mode to use.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraShutterMode**.\n"
		""},
	 { "CameraSettingsBlueFOX_triggerSource_get", _wrap_CameraSettingsBlueFOX_triggerSource_get, METH_O, "\n"
		"An enumerated integer property defining where the trigger signal is expected to occur.\n"
		"When working with hardware generated signals via **mvIMPACT::acquire::RTCtrProgram** objects\n"
		"this property should be set to **mvIMPACT::acquire::ctsRTCtrl** as otherwise\n"
		"the program will not affect the behaviour of the camera.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTriggerSource**.\n"
		""},
	 { "CameraSettingsBlueFOX_sensorTimingMode_get", _wrap_CameraSettingsBlueFOX_sensorTimingMode_get, METH_O, "\n"
		"An enumerated integer property defining the current image sensor timing mode.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXSensorTiming**.\n"
		""},
	 { "delete_CameraSettingsBlueFOX", _wrap_delete_CameraSettingsBlueFOX, METH_O, NULL},
	 { "CameraSettingsBlueFOX_swigregister", CameraSettingsBlueFOX_swigregister, METH_O, NULL},
	 { "CameraSettingsBlueFOX_swiginit", CameraSettingsBlueFOX_swiginit, METH_VARARGS, NULL},
	 { "new_CameraSettingsBlueCOUGAR", _wrap_new_CameraSettingsBlueCOUGAR, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::CameraSettingsBlueCOUGAR** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "delete_CameraSettingsBlueCOUGAR", _wrap_delete_CameraSettingsBlueCOUGAR, METH_O, NULL},
	 { "CameraSettingsBlueCOUGAR_getTriggerControlCount", _wrap_CameraSettingsBlueCOUGAR_getTriggerControlCount, METH_O, "\n"
		"Returns the number of **mvIMPACT::acquire::TriggerControls** available for this device.\n"
		"This might be 0 if the device either does not support this feature.\n"
		""},
	 { "CameraSettingsBlueCOUGAR_triggerControl", _wrap_CameraSettingsBlueCOUGAR_triggerControl, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns a const pointer to a **mvIMPACT::acquire::TriggerControl** object.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* references an invalid pin an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		" Notes: \n"
		" The features of each **mvIMPACT::acquire::TriggerControl** will only be visible and thus available,\n"
		" when **mvIMPACT::acquire::CameraSettingsBlueCOUGAR::triggerInterface**\n"
		" is set to **mvIMPACT::acquire::dtiAdvanced**.\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the trigger control\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns a const pointer to a **mvIMPACT::acquire::TriggerControl** object or NULL if the name passed to the function does not specify a valid trigger control.\n"
		":type name: string\n"
		":param name: [in] The name of the trigger control\n"
		""},
	 { "CameraSettingsBlueCOUGAR_getHDRControl", _wrap_CameraSettingsBlueCOUGAR_getHDRControl, METH_O, " Returns the **mvIMPACT::acquire::HDRControl** object associated with this setting."},
	 { "CameraSettingsBlueCOUGAR_frameRate_Hz_get", _wrap_CameraSettingsBlueCOUGAR_frameRate_Hz_get, METH_O, "\n"
		"A float property defining the frame rate (in Hz) this device shall use to transfer images.\n"
		"Depending on other parameters the desired frame rate might not be achievable (e.g. if the exposure time\n"
		"is higher than the frame period. In that case the device will automatically reduce the frame rate.\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "CameraSettingsBlueCOUGAR_partialScanMode_get", _wrap_CameraSettingsBlueCOUGAR_partialScanMode_get, METH_O, "\n"
		"An enumerated integer property defining whether partial scan mode shall be used or not.\n"
		"This property currently is only available for **mvBlueCOUGAR-S** devices. When partial scan mode is active, the\n"
		"frame rate can no longer be controlled be the property **mvIMPACT::acquire::CameraSettingsBlueCOUGAR::frameRate_Hz**.\n"
		"The device will always transmit frames as fast as possible instead.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "CameraSettingsBlueCOUGAR_triggerInterface_get", _wrap_CameraSettingsBlueCOUGAR_triggerInterface_get, METH_O, "\n"
		"An enumerated integer property defining which view of the trigger interface to use.\n"
		"This property mainly switches the visibility of trigger the different trigger interfaces. After applying changes to\n"
		"this property all trigger related features might have a different visibility. However the documentation will state\n"
		"what features are available in which mode.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceTriggerInterface**.\n"
		""},
	 { "CameraSettingsBlueCOUGAR_triggerSource_get", _wrap_CameraSettingsBlueCOUGAR_triggerSource_get, METH_O, "\n"
		"An enumerated integer property defining where the trigger signal is expected to occur.\n"
		"When working with hardware generated signals via **mvIMPACT::acquire::RTCtrProgram** objects\n"
		"this property should be set to **mvIMPACT::acquire::ctsRTCtrl** as otherwise\n"
		"the program will not affect the behaviour of the camera.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTriggerSource**.\n"
		"\n"
		"Notes: \n"
		"This feature will only be visible and thus available, when **mvIMPACT::acquire::CameraSettingsBlueCOUGAR::triggerInterface**\n"
		"is set to **mvIMPACT::acquire::dtiStandard**.\n"
		""},
	 { "CameraSettingsBlueCOUGAR_acquisitionBurstFrameCount_get", _wrap_CameraSettingsBlueCOUGAR_acquisitionBurstFrameCount_get, METH_O, "\n"
		"A 64-bit integer property defining the number of frames to acquire for each FrameBurstStart trigger.\n"
		"Notes: \n"
		"This feature will only be taken into account if the ``FrameBurstStart`` trigger is active when **mvIMPACT::acquire::CameraSettingsBlueCOUGAR::triggerInterface**\n"
		"is set to **mvIMPACT::acquire::dtiAdvanced**.\n"
		""},
	 { "CameraSettingsBlueCOUGAR_swigregister", CameraSettingsBlueCOUGAR_swigregister, METH_O, NULL},
	 { "CameraSettingsBlueCOUGAR_swiginit", CameraSettingsBlueCOUGAR_swiginit, METH_VARARGS, NULL},
	 { "new_CameraSettingsFrameGrabber", _wrap_new_CameraSettingsFrameGrabber, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::CameraSettingsFrameGrabber** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "delete_CameraSettingsFrameGrabber", _wrap_delete_CameraSettingsFrameGrabber, METH_O, NULL},
	 { "CameraSettingsFrameGrabber_getTriggerControlCount", _wrap_CameraSettingsFrameGrabber_getTriggerControlCount, METH_O, "\n"
		"Returns the number of **mvIMPACT::acquire::TriggerControls** available for this device.\n"
		"This might be 0 if the device either does not support this feature.\n"
		""},
	 { "CameraSettingsFrameGrabber_triggerControl", _wrap_CameraSettingsFrameGrabber_triggerControl, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns a const pointer to a **mvIMPACT::acquire::TriggerControl** object.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If *nr* references an invalid pin an STL out_of_range exception\n"
		" will be thrown.\n"
		" }\n"
		"\n"
		":type nr: int\n"
		":param nr: [in] The number of the trigger control\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns a const pointer to a **mvIMPACT::acquire::TriggerControl** object or NULL if the name passed to the function does not specify a valid trigger control.\n"
		":type name: string\n"
		":param name: [in] The name of the trigger control\n"
		""},
	 { "CameraSettingsFrameGrabber_type_get", _wrap_CameraSettingsFrameGrabber_type_get, METH_O, "\n"
		"An enumerated integer property defining the camera description used for the image acquisition.\n"
		"This property **ALWAYS** defines a translation dictionary containing a string representation\n"
		"and a numerical value for the camera descriptions available for the device. The string\n"
		"representation of the camera description will be built from the property name of the class this\n"
		"camera description belongs to (e.g. *'Standard'*, *'NonStandard'* or *'CameraLink')* and\n"
		"the name of the camera description itself. Assuming a the device can handle standard\n"
		"video cameras and a description for a camera named *'MyCCIRCamera'* will therefore\n"
		"add *'Standard_MyCCIRCamera'* and a unique numerical representation to the properties\n"
		"translation dictionary.\n"
		""},
	 { "CameraSettingsFrameGrabber_aoiMode_get", _wrap_CameraSettingsFrameGrabber_aoiMode_get, METH_O, "\n"
		"An enumerated integer property defining the used AOI mode for the image capture.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraAoiMode**.\n"
		""},
	 { "CameraSettingsFrameGrabber_gain_dB_get", _wrap_CameraSettingsFrameGrabber_gain_dB_get, METH_O, "\n"
		"A float property defining the gain in dB.\n"
		"This is the gain applied during the analogue to digital conversion inside the frame\n"
		"grabber, not applied inside the camera.\n"
		"\n"
		"* The formula for given ``gain_dB`` is\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    gain_x= 10 ^ (gain_dB/20)\n"
		"\n"
		"**Example**:\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    gain_x = 10 ^ (6/20) = 1.995\n"
		"\n"
		"I.e. increasing the gain setting by 6dB corresponds to factor of 2.\n"
		"\n"
		"The formula for given gain_x is\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"    gain_dB = 20*log(gain_x) dB\n"
		"\n"
		"Where:\n"
		"\n"
		"``gain_dB``: MATRIX VISION gain value (logarithmic)\n"
		"\n"
		"``gain_x``: multiplicative gain\n"
		"\n"
		"``^``: power function\n"
		"\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_offset_mV_get", _wrap_CameraSettingsFrameGrabber_offset_mV_get, METH_O, "\n"
		"An integer property defining the offset in milli-Volt.\n"
		"This is the analogue offset applied during the analogue to digital conversion inside the frame\n"
		"grabber, not applied inside the camera.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_scanClock_get", _wrap_CameraSettingsFrameGrabber_scanClock_get, METH_O, "\n"
		"An enumerated integer property defining the scan clock mode used for the current acquisition.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TScanClock**.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception! Digital frame grabbers will however **NOT** support\n"
		"this property.\n"
		""},
	 { "CameraSettingsFrameGrabber_triggerMode_get", _wrap_CameraSettingsFrameGrabber_triggerMode_get, METH_O, "\n"
		"An enumerated integer property defining the behaviour of the frame grabbers trigger input.\n"
		"Notes: \n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceTriggerMode**. However\n"
		"not every device will offer all these trigger modes but a subset of them. Valid trigger modes therefore\n"
		"can be found by reading the properties translation dictionary.\n"
		"\n"
		"\n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_softwareTriggerPeriod_ms_get", _wrap_CameraSettingsFrameGrabber_softwareTriggerPeriod_ms_get, METH_O, "\n"
		"An integer property defining the software simulated trigger period.\n"
		"When **mvIMPACT::acquire::CameraSettingsFrameGrabber::triggerMode** is set to\n"
		"**mvIMPACT::acquire::dtmPeriodically** this property defines the\n"
		"interval between two consecutive external trigger events simulated by the driver.\n"
		"\n"
		"Currently this property is only available for **mvTITAN** and **mvGAMMA** frame grabbers.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_serialPortBaudrate_get", _wrap_CameraSettingsFrameGrabber_serialPortBaudrate_get, METH_O, "\n"
		"An enumerated integer property defining the baud rate of the serial communication port between frame grabber and camera.\n"
		"Currently this property is only available for CameraLink(R) frame grabbers.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraSerialPortBaudRate**.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_interlacedMode_get", _wrap_CameraSettingsFrameGrabber_interlacedMode_get, METH_O, "\n"
		"An enumerated integer property defining how the image from the camera shall be captured.\n"
		"If a video signal is transmitted to the capture device in an interlaced format, the device\n"
		"can either capture each individual frame, or merge two frames together into a complete image.\n"
		"\n"
		"This property will be invisible when the camera description selected by the property\n"
		"**mvIMPACT::acquire::CameraSettingsFrameGrabber::type** does define it property\n"
		"**mvIMPACT::acquire::CameraDescriptionBase::interlacedType** to be **mvIMPACT::acquire::citNone**\n"
		"as the decision whether an interlaced image shall be reconstructed from frames or left\n"
		"as individual frame is redundant if the video source transmits full frames only.\n"
		"\n"
		"The visibility of a property can be checked by calling **mvIMPACT::acquire::Component::isVisible**\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInterlacedMode**.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_acquisitionField_get", _wrap_CameraSettingsFrameGrabber_acquisitionField_get, METH_O, "\n"
		"An enumerated integer property defining which frame(s) of an interlaced video signal will be digitised or triggers the start of the acquisition.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAcquisitionField**.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_scanRateMode_get", _wrap_CameraSettingsFrameGrabber_scanRateMode_get, METH_O, "\n"
		"An enumerated integer property defining the scan rate mode for this setting.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceScanRateMode**.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_scanRate_kHz_get", _wrap_CameraSettingsFrameGrabber_scanRate_kHz_get, METH_O, "\n"
		"An integer property defining the current scan frequency of the capture device.\n"
		"This property is only visible if the **mvIMPACT::acquire::CameraSettingsFrameGrabber::scanRateMode**\n"
		"property is **NOT** in an auto mode.\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_luminance_pc_get", _wrap_CameraSettingsFrameGrabber_luminance_pc_get, METH_O, "\n"
		"An integer property defining the luminance value to be applied to the image data by the frame grabber in per cent.\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_saturation_pc_get", _wrap_CameraSettingsFrameGrabber_saturation_pc_get, METH_O, "\n"
		"An integer property defining the saturation value to be applied to the image data by the frame grabber in per cent.\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_hue_pc_get", _wrap_CameraSettingsFrameGrabber_hue_pc_get, METH_O, "\n"
		"An integer property defining the hue value to be applied to the image data by the frame grabber in per cent.\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_contrast_pc_get", _wrap_CameraSettingsFrameGrabber_contrast_pc_get, METH_O, "\n"
		"An integer property defining the contrast value to be applied to the image data by the frame grabber in per cent.\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_lineCounter_get", _wrap_CameraSettingsFrameGrabber_lineCounter_get, METH_O, "\n"
		"An enumerated integer property defining the way line counter information is handled by the device.\n"
		"This is interesting for line scan camera applications.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLineCounter**.\n"
		"\n"
		"Notes: \n"
		"This property will not be available for every frame grabber, so before using it, check\n"
		"if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing\n"
		"an invalid property will raise an exception!\n"
		""},
	 { "CameraSettingsFrameGrabber_swigregister", CameraSettingsFrameGrabber_swigregister, METH_O, NULL},
	 { "CameraSettingsFrameGrabber_swiginit", CameraSettingsFrameGrabber_swiginit, METH_VARARGS, NULL},
	 { "CameraDescriptionBase_getClassName", _wrap_CameraDescriptionBase_getClassName, METH_O, "\n"
		"Returns the class this description is belonging to.\n"
		":rtype: string\n"
		":return: The class this description is belonging to.\n"
		""},
	 { "CameraDescriptionBase_copyDescription", _wrap_CameraDescriptionBase_copyDescription, METH_VARARGS, "\n"
		" Creates a new camera description list as a copy of the current one.\n"
		" This function can be used to create a new camera description list. It will create\n"
		" a deep copy of the properties referenced by this camera description and will append the new description\n"
		" to the list of camera descriptions.\n"
		"\n"
		" Notes: \n"
		" This will **NOT** store the new description permanently. After the driver has been\n"
		" closed, this data will be lost. To store the new list in a way that it will be available\n"
		" the next time the driver/device is opened again, **mvIMPACT::acquire::CameraDescriptionBase::exportDescription** must\n"
		" be called with the handle of the newly created description after this function.\n"
		" See also: \n"
		" **mvIMPACT::acquire::CameraDescriptionBase::exportDescription**,\n"
		"\n"
		" **mvIMPACT::acquire::CameraDescriptionBase::importDescription**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** if new name matches a description that is already\n"
		"     existing.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		"\n"
		":type newName: string\n"
		":param newName: [in] The name for the newly created camera description. This name **MUST** NOT match a description already existing.\n"
		""},
	 { "CameraDescriptionBase_exportDescription", _wrap_CameraDescriptionBase_exportDescription, METH_O, "\n"
		" Stores the current camera description on disc.\n"
		" This function can be used to store the current settings of a camera description\n"
		" permanently so that the next time the driver is initialized these settings are restored.\n"
		"\n"
		" When exporting a camera description a file in XML format will be written to disc. On\n"
		" Windows(R) camera descriptions will be stored under\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     %PUBLIC%/Documents/MATRIX VISION/mvIMPACT Acquire/CameraFiles\n"
		" or\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     %MVIMPACT_ACQUIRE_DATA_DIR%/CameraFiles\n"
		" which will point to the same folder), on Linux(R) this directory will be\n"
		"\n"
		" .. code-block:: c++\n"
		"\n"
		"     /etc/matrix-vision/mvimpact-acquire/camerafiles\n"
		" while under other platforms these files will end up in the current working directory. This behaviour can be modified\n"
		" by writing the property **mvIMPACT::acquire::Device::customDataDirectory** before initialising the\n"
		" device.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::CameraDescriptionBase::copyDescription**,\n"
		"\n"
		" **mvIMPACT::acquire::CameraDescriptionBase::importDescription**\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		""},
	 { "CameraDescriptionBase_importDescription", _wrap_CameraDescriptionBase_importDescription, METH_O, "\n"
		" Updates a camera description with the data stored in a previous session or with the original default data.\n"
		" When importing a camera description the device driver will try to retrieve the parameters\n"
		" needed from an XML file. On Windows(R) camera descriptions MUST be stored under\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     %PUBLIC%/Documents/MATRIX VISION/mvIMPACT Acquire/CameraFiles\n"
		" or\n"
		"\n"
		".. code-block:: c++\n"
		"\n"
		"     %MVIMPACT_ACQUIRE_DATA_DIR%/CameraFiles\n"
		" which will point to the same folder), under Linux(R) this directory will be\n"
		"\n"
		" .. code-block:: c++\n"
		"\n"
		"     /etc/matrix-vision/mvimpact-acquire/camerafiles\n"
		" while under other platforms these files MUST be located in the current working directory.\n"
		" This behaviour can be modified by writing the property **mvIMPACT::acquire::Device::customDataDirectory** before initialising the device.\n"
		" To get access to an XML description file within the application, these file must be copied to\n"
		" this directory **BEFORE** the device is initialized. During the initialisation process the\n"
		" device driver will process every file located under this location and will add them to\n"
		" the internal list of descriptions. Every camera located during this process and also descriptions\n"
		" created later on during the program operation can be selected via the property\n"
		" **mvIMPACT::acquire::CameraSettingsFrameGrabber::type**.\n"
		"\n"
		" Notes: \n"
		" In order not to bloat the device driver with redundant data it's wise only to store the\n"
		" descriptions needed for the application to run under this location.\n"
		"\n"
		"\n"
		" Only camera descriptions supported by the capture device will be added to the device\n"
		" drivers internal list and will therefore be accessible via the\n"
		" **mvIMPACT::acquire::CameraDescriptionManager**.\n"
		"\n"
		" To restore the default values valid during the driver was initialized the function\n"
		" **mvIMPACT::acquire::ComponentCollection::restoreDefault** can be used as well.\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::CameraDescriptionBase::exportDescription**,\n"
		"\n"
		"    mvIMPACT::acquire::CameraDescriptionBase::copyDescription\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.\n"
		""},
	 { "CameraDescriptionBase_name_get", _wrap_CameraDescriptionBase_name_get, METH_O, " A string property **read-only** containing the name of this camera description list."},
	 { "CameraDescriptionBase_videoOutput_get", _wrap_CameraDescriptionBase_videoOutput_get, METH_O, "\n"
		"An enumerated integer property defining the type of video outputs this camera offers.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraOutput**.\n"
		"\n"
		"Notes: \n"
		"This property will be **(read-only)** for camera descriptions of type\n"
		"**mvIMPACT::acquire::CameraDescriptionCameraLink** and **mvIMPACT::acquire::CameraDescriptionSDI**\n"
		"as for these camera types the video output depends on certain other parameters according to the\n"
		"corresponding standard.\n"
		""},
	 { "CameraDescriptionBase_interlacedType_get", _wrap_CameraDescriptionBase_interlacedType_get, METH_O, "\n"
		"An enumerated integer property defining how the camera transmits image data.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraInterlacedType**.\n"
		""},
	 { "CameraDescriptionBase_aoiHeight_get", _wrap_CameraDescriptionBase_aoiHeight_get, METH_O, " An integer property defining the number of active lines to capture from the camera."},
	 { "CameraDescriptionBase_aoiStartX_get", _wrap_CameraDescriptionBase_aoiStartX_get, METH_O, " An integer property defining the X-offset in pixels to the first active pixel to capture."},
	 { "CameraDescriptionBase_aoiStartY_get", _wrap_CameraDescriptionBase_aoiStartY_get, METH_O, " An integer property defining the Y-offset in lines to the first active line to capture."},
	 { "CameraDescriptionBase_aoiWidth_get", _wrap_CameraDescriptionBase_aoiWidth_get, METH_O, " An integer property defining the number of active pixels to capture per line."},
	 { "delete_CameraDescriptionBase", _wrap_delete_CameraDescriptionBase, METH_O, NULL},
	 { "CameraDescriptionBase_swigregister", CameraDescriptionBase_swigregister, METH_O, NULL},
	 { "CameraDescriptionDigitalBase_bitsPerPixel_get", _wrap_CameraDescriptionDigitalBase_bitsPerPixel_get, METH_O, " An integer property defining the number of bits per pixel currently transmitted by this camera."},
	 { "CameraDescriptionDigitalBase_format_get", _wrap_CameraDescriptionDigitalBase_format_get, METH_O, "\n"
		"An enumerated integer property defining the data format the camera is sending image data.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraDataFormat**.\n"
		""},
	 { "CameraDescriptionDigitalBase_bayerParity_get", _wrap_CameraDescriptionDigitalBase_bayerParity_get, METH_O, "\n"
		"An enumerated integer property defining the start pixel for a camera delivering an unconverted bayer image.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.\n"
		""},
	 { "delete_CameraDescriptionDigitalBase", _wrap_delete_CameraDescriptionDigitalBase, METH_O, NULL},
	 { "CameraDescriptionDigitalBase_swigregister", CameraDescriptionDigitalBase_swigregister, METH_O, NULL},
	 { "CameraDescriptionSDI_videoStandard_get", _wrap_CameraDescriptionSDI_videoStandard_get, METH_O, "\n"
		"An enumerated integer property for defining the video standard this camera is compliant with.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TVideoStandard**.\n"
		""},
	 { "delete_CameraDescriptionSDI", _wrap_delete_CameraDescriptionSDI, METH_O, NULL},
	 { "CameraDescriptionSDI_swigregister", CameraDescriptionSDI_swigregister, METH_O, NULL},
	 { "CameraDescriptionDigitalBase2_pixelsPerCycle_get", _wrap_CameraDescriptionDigitalBase2_pixelsPerCycle_get, METH_O, "\n"
		"An integer property defining the number of pixels per clock cycle transmitted by this camera.\n"
		"This corresponds the number of taps used by the camera in the described configuration.\n"
		""},
	 { "CameraDescriptionDigitalBase2_scanMode_get", _wrap_CameraDescriptionDigitalBase2_scanMode_get, METH_O, "\n"
		"An enumerated integer property providing information about the sensor of this camera.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraScanMode**.\n"
		""},
	 { "delete_CameraDescriptionDigitalBase2", _wrap_delete_CameraDescriptionDigitalBase2, METH_O, NULL},
	 { "CameraDescriptionDigitalBase2_swigregister", CameraDescriptionDigitalBase2_swigregister, METH_O, NULL},
	 { "CameraDescriptionCameraLink_dataValid_get", _wrap_CameraDescriptionCameraLink_dataValid_get, METH_O, "\n"
		"An enumerated integer property defining the way this camera transmits the data valid (**DVAL)** signal.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraLinkDataValidMode**.\n"
		""},
	 { "CameraDescriptionCameraLink_tapsXGeometry_get", _wrap_CameraDescriptionCameraLink_tapsXGeometry_get, METH_O, "\n"
		"An enumerated integer property defining the way this camera transmits the pixel data in X direction.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTapsXGeometry**.\n"
		""},
	 { "CameraDescriptionCameraLink_tapsYGeometry_get", _wrap_CameraDescriptionCameraLink_tapsYGeometry_get, METH_O, "\n"
		"An enumerated integer property defining the way this camera transmits the pixel data in Y direction.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTapsYGeometry**.\n"
		""},
	 { "delete_CameraDescriptionCameraLink", _wrap_delete_CameraDescriptionCameraLink, METH_O, NULL},
	 { "CameraDescriptionCameraLink_swigregister", CameraDescriptionCameraLink_swigregister, METH_O, NULL},
	 { "CameraDescriptionDigital_frameSync_get", _wrap_CameraDescriptionDigital_frameSync_get, METH_O, "\n"
		"An enumerated integer property defining the edge valid for the frame sync signal of this camera.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.\n"
		"\n"
		"Notes: \n"
		"Not every value defined by this enumeration will be supported by this property. Check which values\n"
		"are available by reading the properties translation dictionary with\n"
		"the functions **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictValue**\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		""},
	 { "CameraDescriptionDigital_lineSync_get", _wrap_CameraDescriptionDigital_lineSync_get, METH_O, "\n"
		"An enumerated integer property defining the edge valid for the line sync. of this camera.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.\n"
		"\n"
		"Notes: \n"
		"Not every value defined by this enumeration will be supported by this property. Check which values\n"
		"are available by reading the properties translation dictionary with\n"
		"the functions **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictValue**\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		""},
	 { "CameraDescriptionDigital_pixelClk_get", _wrap_CameraDescriptionDigital_pixelClk_get, METH_O, "\n"
		"An enumerated integer property defining the edge valid for the pixel clock of this camera.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.\n"
		"\n"
		"Notes: \n"
		"Not every value defined by this enumeration will be supported by this property. Check which values\n"
		"are available by reading the properties translation dictionary with\n"
		"the functions **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictString** and\n"
		"**mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictValue**\n"
		"If: DOXYGEN_CPP_DOCUMENTATION {\n"
		"C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDict**\n"
		"in addition to the functions mentioned above.\n"
		"}\n"
		""},
	 { "delete_CameraDescriptionDigital", _wrap_delete_CameraDescriptionDigital, METH_O, NULL},
	 { "CameraDescriptionDigital_swigregister", CameraDescriptionDigital_swigregister, METH_O, NULL},
	 { "CameraDescriptionStandardBase_videoStandard_get", _wrap_CameraDescriptionStandardBase_videoStandard_get, METH_O, "\n"
		"An enumerated integer property for defining the video standard this camera is compliant with.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TVideoStandard**.\n"
		""},
	 { "CameraDescriptionStandardBase_scanStandard_get", _wrap_CameraDescriptionStandardBase_scanStandard_get, METH_O, "\n"
		"An enumerated integer property defining the scan standard this camera is compliant with.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TScanStandard**.\n"
		""},
	 { "CameraDescriptionStandardBase_scanRate_kHz_get", _wrap_CameraDescriptionStandardBase_scanRate_kHz_get, METH_O, " An integer property containing the scan rate in kHz needed to driver the AD converter of the capture device with to convert the video signal properly."},
	 { "CameraDescriptionStandardBase_startField_get", _wrap_CameraDescriptionStandardBase_startField_get, METH_O, "\n"
		"An enumerated integer property containing information about the first field transmitted by a camera.\n"
		"A camera might transmit either the odd or the even field of an interlaced video signal first.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAcquisitionField**.\n"
		""},
	 { "delete_CameraDescriptionStandardBase", _wrap_delete_CameraDescriptionStandardBase, METH_O, NULL},
	 { "CameraDescriptionStandardBase_swigregister", CameraDescriptionStandardBase_swigregister, METH_O, NULL},
	 { "delete_CameraDescriptionStandard", _wrap_delete_CameraDescriptionStandard, METH_O, NULL},
	 { "CameraDescriptionStandard_swigregister", CameraDescriptionStandard_swigregister, METH_O, NULL},
	 { "CameraDescriptionNonStandard_lineFrequency_Hz_get", _wrap_CameraDescriptionNonStandard_lineFrequency_Hz_get, METH_O, " An integer property containing the line frequency of this camera in Hertz."},
	 { "CameraDescriptionNonStandard_VDOutput_get", _wrap_CameraDescriptionNonStandard_VDOutput_get, METH_O, "\n"
		"An enumerated integer property defining whether the vertical sync. information is part of the video signal or transmitted via a separate wire.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.\n"
		""},
	 { "CameraDescriptionNonStandard_HDOutput_get", _wrap_CameraDescriptionNonStandard_HDOutput_get, METH_O, "\n"
		"An enumerated integer property defining whether the horizontal sync. information is part of the video signal or transmitted via a separate wire.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.\n"
		""},
	 { "CameraDescriptionNonStandard_syncOutput_get", _wrap_CameraDescriptionNonStandard_syncOutput_get, METH_O, "\n"
		"An enumerated integer property for RGB cameras containing information where the sync. information is transmitted.\n"
		"This can either be within one of the three color components or on a separate wire.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncOutput**.\n"
		""},
	 { "CameraDescriptionNonStandard_pixelClockOutput_get", _wrap_CameraDescriptionNonStandard_pixelClockOutput_get, METH_O, "\n"
		"An enumerated integer property containing information whether the pixel clock is part of the video signal or not.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.\n"
		""},
	 { "CameraDescriptionNonStandard_fieldGateMode_get", _wrap_CameraDescriptionNonStandard_fieldGateMode_get, METH_O, "\n"
		"An enumerated integer property defining the clamp mode for this camera description.\n"
		"This defines how the field detection(ODD/EVEN) is done.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TFieldGateMode**.\n"
		""},
	 { "CameraDescriptionNonStandard_fieldGateStart_get", _wrap_CameraDescriptionNonStandard_fieldGateStart_get, METH_O, "\n"
		"An integer property defining the start position (in pixel clocks) of the field gate detection area.\n"
		"This will only need modification in very rare cases.\n"
		""},
	 { "CameraDescriptionNonStandard_fieldGateWidth_get", _wrap_CameraDescriptionNonStandard_fieldGateWidth_get, METH_O, "\n"
		"An integer property defining the width (in pixel clocks) of the field gate detection area.\n"
		"This will only need modification in very rare cases.\n"
		""},
	 { "CameraDescriptionNonStandard_clampMode_get", _wrap_CameraDescriptionNonStandard_clampMode_get, METH_O, "\n"
		"An enumerated integer property defining the clamp mode for this camera description.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TClampMode**.\n"
		""},
	 { "CameraDescriptionNonStandard_clampStart_us_get", _wrap_CameraDescriptionNonStandard_clampStart_us_get, METH_O, "\n"
		"The clamp start position defines where in each line of the video signal the frame grabber assumes the black level position.\n"
		"This will only need modification in very rare cases.\n"
		""},
	 { "delete_CameraDescriptionNonStandard", _wrap_delete_CameraDescriptionNonStandard, METH_O, NULL},
	 { "CameraDescriptionNonStandard_swigregister", CameraDescriptionNonStandard_swigregister, METH_O, NULL},
	 { "new_CameraDescriptionManager", _wrap_new_CameraDescriptionManager, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new **mvIMPACT::acquire::CameraDescriptionManager** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire:**:>DeviceManager object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::CameraDescriptionManager** from an existing one.\n"
		":type src: :py:class:`CameraDescriptionManager`\n"
		":param src: A constant reference to the **mvIMPACT::acquire::CameraDescriptionManager** object, this object shall be created from\n"
		""},
	 { "delete_CameraDescriptionManager", _wrap_delete_CameraDescriptionManager, METH_O, " Class destructor."},
	 { "CameraDescriptionManager_getCLCameraDescriptionCount", _wrap_CameraDescriptionManager_getCLCameraDescriptionCount, METH_O, " Returns the number of CameraLink(R) camera descriptions currently available for the device that constructed this instance of the class."},
	 { "CameraDescriptionManager_cameraDescriptionCameraLink", _wrap_CameraDescriptionManager_cameraDescriptionCameraLink, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionCameraLink** object specifying the camera description found at the given index in the camera description managers internal list.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If the index is either equal or higher than the number of CameraLink(R) camera descriptions\n"
		"\n"
		" detected for this device an STL out_of_range exception will be thrown.\n"
		" }\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the camera description to return\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionCameraLink** object specifying the camera description with the given name in the camera description managers internal list.\n"
		" :rtype: :py:class:`CameraDescriptionCameraLink`\n"
		" :return: \n"
		"     - a pointer to a **mvIMPACT::acquire::CameraDescriptionCameraLink** object specifying the camera\n"
		"     description with the given name in the camera description managers internal list if a camera\n"
		"     description with *name* is available.\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'CameraLink_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.\n"
		""},
	 { "CameraDescriptionManager_getSDICameraDescriptionCount", _wrap_CameraDescriptionManager_getSDICameraDescriptionCount, METH_O, " Returns the number of SDI camera descriptions currently available for the device that constructed this instance of the class."},
	 { "CameraDescriptionManager_cameraDescriptionSDI", _wrap_CameraDescriptionManager_cameraDescriptionSDI, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionSDI** object specifying the camera description found at the given index in the camera description managers internal list.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If the index is either equal or higher than the number of SDI camera descriptions\n"
		"\n"
		" detected for this device an STL out_of_range exception will be thrown.\n"
		" }\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the camera description to return\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionSDI** object specifying the camera description with the given name in the camera description managers internal list.\n"
		" :rtype: :py:class:`CameraDescriptionSDI`\n"
		" :return: \n"
		"     - a pointer to a **mvIMPACT::acquire::CameraDescriptionSDI** object specifying the camera\n"
		"     description with the given name in the camera description managers internal list if a camera\n"
		"     description with *name* is available.\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'CameraLink_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.\n"
		""},
	 { "CameraDescriptionManager_getDigitalCameraDescriptionCount", _wrap_CameraDescriptionManager_getDigitalCameraDescriptionCount, METH_O, " Returns the number of non-standard digital camera descriptions currently available for the device that constructed this instance of the class."},
	 { "CameraDescriptionManager_cameraDescriptionDigital", _wrap_CameraDescriptionManager_cameraDescriptionDigital, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionDigital** object specifying the camera description found at the given index in the camera description managers internal list.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If the index is either equal or higher than the number of non-standard digital camera descriptions\n"
		"\n"
		" detected for this device an STL out_of_range exception will be thrown.\n"
		" }\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the camera description to return\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionDigital** object specifying the camera description with the given name in the camera description managers internal list.\n"
		" :rtype: :py:class:`CameraDescriptionDigital`\n"
		" :return: \n"
		"     - a pointer to a **mvIMPACT::acquire::CameraDescriptionDigital** object specifying the camera\n"
		"     description with the given name in the camera description managers internal list if a camera\n"
		"     description with *name* is available.\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'Digital_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.\n"
		""},
	 { "CameraDescriptionManager_getStandardCameraDescriptionCount", _wrap_CameraDescriptionManager_getStandardCameraDescriptionCount, METH_O, " Returns the number of standard camera descriptions currently available for the device that constructed this instance of the class."},
	 { "CameraDescriptionManager_cameraDescriptionStandard", _wrap_CameraDescriptionManager_cameraDescriptionStandard, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionStandard** object specifying the camera description found at the given index in the camera description managers internal list.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If the index is either equal or higher than the number of standard camera descriptions\n"
		"\n"
		" detected for this device an STL out_of_range exception will be thrown.\n"
		" }\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the camera description to return\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionStandard** object specifying the camera description with the given name in the camera description managers internal list.\n"
		" :rtype: :py:class:`CameraDescriptionStandard`\n"
		" :return: \n"
		"     - a pointer to a **mvIMPACT::acquire::CameraDescriptionStandard** object specifying the camera\n"
		"     description with the given name in the camera description managers internal list if a camera\n"
		"     description with *name* is available.\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'Standard_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.\n"
		""},
	 { "CameraDescriptionManager_getNonStandardCameraDescriptionCount", _wrap_CameraDescriptionManager_getNonStandardCameraDescriptionCount, METH_O, " Returns the number of non-standard camera descriptions currently available for the device that constructed this instance of the class."},
	 { "CameraDescriptionManager_cameraDescriptionNonStandard", _wrap_CameraDescriptionManager_cameraDescriptionNonStandard, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionNonStandard** object specifying the camera description found at the given index in the camera description managers internal list.\n"
		" If: DOXYGEN_CPP_DOCUMENTATION {\n"
		" If the index is either equal or higher than the number of non-standard camera descriptions\n"
		"\n"
		" detected for this device an STL out_of_range exception will be thrown.\n"
		" }\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the camera description to return\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionNonStandard** object specifying the camera description with the given name in the camera description managers internal list.\n"
		" :rtype: :py:class:`CameraDescriptionNonStandard`\n"
		" :return: \n"
		"     - a pointer to a **mvIMPACT::acquire::CameraDescriptionNonStandard** object specifying the camera\n"
		"     description with the given name in the camera description managers internal list if a camera\n"
		"     description with *name* is available.\n"
		"     - an invalid pointer or reference otherwise.\n"
		"\n"
		":type name: string\n"
		":param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'NonStandard_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.\n"
		""},
	 { "CameraDescriptionManager_getTotalCameraDescriptionCount", _wrap_CameraDescriptionManager_getTotalCameraDescriptionCount, METH_O, "\n"
		"Returns the total number camera descriptions currently available for the device that constructed this instance of the class.\n"
		"Since: 2.1.4\n"
		""},
	 { "CameraDescriptionManager_swigregister", CameraDescriptionManager_swigregister, METH_O, NULL},
	 { "CameraDescriptionManager_swiginit", CameraDescriptionManager_swiginit, METH_VARARGS, NULL},
	 { "new_I2CControl", _wrap_new_I2CControl, METH_O, "\n"
		" brief Constructs a new **mvIMPACT::acquire::I2CControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "I2CControl_I2COperationMode_get", _wrap_I2CControl_I2COperationMode_get, METH_O, "\n"
		"An enumerated integer property to select the I2C operation.\n"
		"The selected operation is executed when **mvIMPACT::acquire::I2CControl::I2COperationExecute** is called.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TI2COperationMode**.\n"
		""},
	 { "I2CControl_I2COperationExecute_get", _wrap_I2CControl_I2COperationExecute_get, METH_O, " Calling this function will execute the operation selected by **mvIMPACT::acquire::I2CControl::I2COperationMode**."},
	 { "I2CControl_I2COperationStatus_get", _wrap_I2CControl_I2COperationStatus_get, METH_O, "\n"
		"Represents the I2C operation execution status.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TI2COperationStatus**.\n"
		""},
	 { "I2CControl_I2CDeviceAddress_get", _wrap_I2CControl_I2CDeviceAddress_get, METH_O, " An integer property storing the address of the I2C device to communicate with."},
	 { "I2CControl_I2CDeviceSubAddressWidth_get", _wrap_I2CControl_I2CDeviceSubAddressWidth_get, METH_O, "\n"
		"An enumerated integer property storing the sub-address width(in bits) of the I2C device to communicate with.\n"
		"Valid values for this property are:\n"
		"\n"
		"- 0\n"
		"- 8\n"
		"- 16\n"
		"\n"
		"Notes: \n"
		"This property must be set to 0 for devices not supporting a sub-address.\n"
		""},
	 { "I2CControl_I2CDeviceSubAddress_get", _wrap_I2CControl_I2CDeviceSubAddress_get, METH_O, "\n"
		"An integer property storing the sub-address of the I2C device to communicate with.\n"
		"When **mvIMPACT::acquire::I2CControl::I2CDeviceSubAddressWidth** is set to 0, this property will be ignored.\n"
		""},
	 { "I2CControl_I2CBuffer_get", _wrap_I2CControl_I2CBuffer_get, METH_O, "\n"
		"Defines the intermediate access buffer that allows the exchange of data between the I2C device and the application.\n"
		"This property can store binary data.\n"
		""},
	 { "I2CControl_I2CBufferLength_get", _wrap_I2CControl_I2CBufferLength_get, METH_O, " An integer property controlling the length of the mapping between the I2C device and the **mvIMPACT::acquire::I2CControl::I2CBuffer** property."},
	 { "I2CControl_I2CRead", _wrap_I2CControl_I2CRead, METH_VARARGS, "\n"
		" Read data from an I2C device.\n"
		" This is a convenience function that wraps the property access a little.\n"
		" In order to find out if the command has been executed successfully\n"
		" **mvIMPACT::acquire::I2CControl::I2COperationStatus** should be checked afterwards.\n"
		"\n"
		":type deviceAddress: int\n"
		":param deviceAddress: [in] The address of the I2C device to communicate with.\n"
		":type deviceSubAddress: int\n"
		":param deviceSubAddress: [in] The sub-address of the I2C device to communicate with.\n"
		":type deviceSubAddressWidth: int\n"
		":param deviceSubAddressWidth: [in] The sub-address width(in bits) of the I2C device to communicate with.\n"
		":type byteCnt: int\n"
		":param byteCnt: [in] The amount of bytes to read.\n"
		""},
	 { "I2CControl_I2CWrite", _wrap_I2CControl_I2CWrite, METH_VARARGS, "\n"
		" Write data to a I2C device.\n"
		" This is a convenience function that wraps the property access a little.\n"
		" In order to find out if the command has been executed successfully\n"
		" **mvIMPACT::acquire::I2CControl::I2COperationStatus** should be checked afterwards.\n"
		"\n"
		":type deviceAddress: int\n"
		":param deviceAddress: [in] The address of the I2C device to communicate with.\n"
		":type deviceSubAddress: int\n"
		":param deviceSubAddress: [in] The sub-address of the I2C device to communicate with.\n"
		":type deviceSubAddressWidth: int\n"
		":param deviceSubAddressWidth: [in] The sub-address width(in bits) of the I2C device to communicate with.\n"
		":type data: string\n"
		":param data: [in] The data to write to the I2C device.\n"
		""},
	 { "delete_I2CControl", _wrap_delete_I2CControl, METH_O, NULL},
	 { "I2CControl_swigregister", I2CControl_swigregister, METH_O, NULL},
	 { "I2CControl_swiginit", I2CControl_swiginit, METH_VARARGS, NULL},
	 { "new_MotorFocusControl", _wrap_new_MotorFocusControl, METH_O, "\n"
		" brief Constructs a new **mvIMPACT::acquire::MotorFocusControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "MotorFocusControl_motorFocusSendBuffer_get", _wrap_MotorFocusControl_motorFocusSendBuffer_get, METH_O, "\n"
		"A string property storing a command to be sent to the motor focus.\n"
		"To actually send the command, the function **mvIMPACT::acquire::MotorFocusControl::motorFocusSend** must be executed.\n"
		""},
	 { "MotorFocusControl_motorFocusReceiveBuffer_get", _wrap_MotorFocusControl_motorFocusReceiveBuffer_get, METH_O, " A string property **(read-only)** that will contain answers sent by the motor focus controller."},
	 { "MotorFocusControl_motorFocusSend_get", _wrap_MotorFocusControl_motorFocusSend_get, METH_O, "\n"
		"Calling this function will send the value of **mvIMPACT::acquire::MotorFocusControl::motorFocusSendBuffer** to the hardware.\n"
		"Afterwards **mvIMPACT::acquire::MotorFocusControl::motorFocusReceiveBuffer** will contain the hardwares answer.\n"
		""},
	 { "MotorFocusControl_motorFocusIncrement_get", _wrap_MotorFocusControl_motorFocusIncrement_get, METH_O, " An integer property storing an increment(in encoder counts) that will be used by subsequent calls to **mvIMPACT::acquire::MotorFocusControl::motorFocusNear** and **mvIMPACT::acquire::MotorFocusControl::motorFocusFar** commands."},
	 { "MotorFocusControl_motorFocusNear_get", _wrap_MotorFocusControl_motorFocusNear_get, METH_O, " Calling this function will cause the motor focus to move forward by **mvIMPACT::acquire::MotorFocusControl::motorFocusIncrement** encoder units."},
	 { "MotorFocusControl_motorFocusFar_get", _wrap_MotorFocusControl_motorFocusFar_get, METH_O, " Calling this function will cause the motor focus to move backward by **mvIMPACT::acquire::MotorFocusControl::motorFocusIncrement** encoder units."},
	 { "MotorFocusControl_motorFocusAbsolutePositionCurrent_get", _wrap_MotorFocusControl_motorFocusAbsolutePositionCurrent_get, METH_O, " An integer property **(read-only)** storing the current absolute position(in encoder counts)."},
	 { "MotorFocusControl_motorFocusAbsolutePositionDesired_get", _wrap_MotorFocusControl_motorFocusAbsolutePositionDesired_get, METH_O, " An integer property storing an absolute position(in encoder counts) that will be used by subsequent calls to the **mvIMPACT::acquire::MotorFocusControl::motorFocusMoveToAbsolutePositionDesired** command."},
	 { "MotorFocusControl_motorFocusMoveToAbsolutePositionDesired_get", _wrap_MotorFocusControl_motorFocusMoveToAbsolutePositionDesired_get, METH_O, " Calling this function will cause the motor focus to move to the position defined by the value of **mvIMPACT::acquire::MotorFocusControl::motorFocusAbsolutePositionDesired**."},
	 { "delete_MotorFocusControl", _wrap_delete_MotorFocusControl, METH_O, NULL},
	 { "MotorFocusControl_swigregister", MotorFocusControl_swigregister, METH_O, NULL},
	 { "MotorFocusControl_swiginit", MotorFocusControl_swiginit, METH_VARARGS, NULL},
	 { "new_DigitalIOMeasurementControl", _wrap_new_DigitalIOMeasurementControl, METH_O, "\n"
		" brief Constructs a new **mvIMPACT::acquire::DigitalIOMeasurementControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "DigitalIOMeasurementControl_digitalIOMeasurementMode_get", _wrap_DigitalIOMeasurementControl_digitalIOMeasurementMode_get, METH_O, "\n"
		"An enumerated integer property defining the type of measurement to perform.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigitalIOMeasurementMode**.\n"
		""},
	 { "DigitalIOMeasurementControl_digitalIOMeasurementSource_get", _wrap_DigitalIOMeasurementControl_digitalIOMeasurementSource_get, METH_O, "\n"
		"An enumerated integer property defining where the measurement shall be performed.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigitalIOMeasurementMode**.\n"
		""},
	 { "DigitalIOMeasurementControl_digitalIOMeasurementResult_get", _wrap_DigitalIOMeasurementControl_digitalIOMeasurementResult_get, METH_O, "\n"
		"A float property **(read-only)** that will contain the result of the measurement.\n"
		"Reading this property will automatically perform a new measurement.\n"
		"\n"
		"Notes: \n"
		"Please note that the signal connected to the digital input must match the selected digital input\n"
		"threshold(see **mvIMPACT::acquire::IOSubSystemBlueFOX::digitalInputThreshold)** in order to\n"
		"obtain valid results.\n"
		""},
	 { "delete_DigitalIOMeasurementControl", _wrap_delete_DigitalIOMeasurementControl, METH_O, NULL},
	 { "DigitalIOMeasurementControl_swigregister", DigitalIOMeasurementControl_swigregister, METH_O, NULL},
	 { "DigitalIOMeasurementControl_swiginit", DigitalIOMeasurementControl_swiginit, METH_VARARGS, NULL},
	 { "new_SettingsBlueFOX", _wrap_new_SettingsBlueFOX, METH_VARARGS, "\n"
		" brief Constructs a new **mvIMPACT::acquire::SettingsBlueFOX** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type name: string\n"
		":param name: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "SettingsBlueFOX_cameraSetting_get", _wrap_SettingsBlueFOX_cameraSetting_get, METH_O, " Camera related settings."},
	 { "delete_SettingsBlueFOX", _wrap_delete_SettingsBlueFOX, METH_O, NULL},
	 { "SettingsBlueFOX_swigregister", SettingsBlueFOX_swigregister, METH_O, NULL},
	 { "SettingsBlueFOX_swiginit", SettingsBlueFOX_swiginit, METH_VARARGS, NULL},
	 { "new_SettingsFrameGrabber", _wrap_new_SettingsFrameGrabber, METH_VARARGS, "\n"
		" brief Constructs a new **mvIMPACT::acquire::SettingsFrameGrabber** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type name: string\n"
		":param name: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "SettingsFrameGrabber_cameraSetting_get", _wrap_SettingsFrameGrabber_cameraSetting_get, METH_O, " Camera related settings."},
	 { "SettingsFrameGrabber_connector_get", _wrap_SettingsFrameGrabber_connector_get, METH_O, " Input channel related properties."},
	 { "delete_SettingsFrameGrabber", _wrap_delete_SettingsFrameGrabber, METH_O, NULL},
	 { "SettingsFrameGrabber_swigregister", SettingsFrameGrabber_swigregister, METH_O, NULL},
	 { "SettingsFrameGrabber_swiginit", SettingsFrameGrabber_swiginit, METH_VARARGS, NULL},
	 { "new_SystemBlueFOX", _wrap_new_SystemBlueFOX, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::SystemBlueFOX** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "SystemBlueFOX_transferSize_get", _wrap_SystemBlueFOX_transferSize_get, METH_O, "\n"
		"An enumerated integer property defining the block size of the image data blocks transferred from the device.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXTransferSize**.\n"
		""},
	 { "SystemBlueFOX_footerMode_get", _wrap_SystemBlueFOX_footerMode_get, METH_O, "\n"
		"An enumerated integer property defining the footer mode of the device.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXFooterMode**.\n"
		""},
	 { "SystemBlueFOX_footerCheckEnable_get", _wrap_SystemBlueFOX_footerCheckEnable_get, METH_O, "\n"
		"An enumerated integer property allowing to switch on/off the check of the image footer.\n"
		"The image footer contains certain additional data as e.g. the exposure time as used by the image\n"
		"sensor. To debug transfer related problems it sometimes can be useful to disable all internal\n"
		"data consistency checks by the driver.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "SystemBlueFOX_powerMode_get", _wrap_SystemBlueFOX_powerMode_get, METH_O, "\n"
		"An enumerated integer property defining the power mode of the device.\n"
		"Notes: \n"
		"This property requires at least firmware version 39! See **mvIMPACT::acquire::Device::firmwareVersion** to find\n"
		"out which firmware is currently running on the device or use **mvIMPACT::acquire::Device::updateFirmware()**\n"
		"to update the firmware to the state compiled into the driver.\n"
		"\n"
		"\n"
		"Do **NOT** modify this property when images are acquired in parallel. Switching off or on the power\n"
		"for a device that is capturing images at the same time will result in incorrect images! Therefore\n"
		"always make sure to stop image acquisition and clean up **BEFORE** modifying this property.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDevicePowerMode**.\n"
		""},
	 { "SystemBlueFOX_statusLEDEnable_get", _wrap_SystemBlueFOX_statusLEDEnable_get, METH_O, "\n"
		"An enumerated integer property allowing to switch on/off the status LED of the device.\n"
		"Notes: \n"
		"This feature is currently available for mvBlueFOX-MLC devices only.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Since: 2.17.0\n"
		""},
	 { "delete_SystemBlueFOX", _wrap_delete_SystemBlueFOX, METH_O, NULL},
	 { "SystemBlueFOX_swigregister", SystemBlueFOX_swigregister, METH_O, NULL},
	 { "SystemBlueFOX_swiginit", SystemBlueFOX_swiginit, METH_VARARGS, NULL},
	 { "new_SystemV4L2", _wrap_new_SystemV4L2, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::SystemV4L2** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		""},
	 { "SystemV4L2_volume_get", _wrap_SystemV4L2_volume_get, METH_O, "\n"
		"If V4L2 device supports audio, this integer property adjusts the audio volume.\n"
		"This property represents a V4L2-audio-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "SystemV4L2_balance_get", _wrap_SystemV4L2_balance_get, METH_O, "\n"
		"If V4L2 device supports audio, this integer property adjusts the audio balance.\n"
		"This property represents a V4L2-audio-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "SystemV4L2_bass_get", _wrap_SystemV4L2_bass_get, METH_O, "\n"
		"If V4L2 device supports audio, this integer property adjusts the audio bass.\n"
		"This property represents a V4L2-audio-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "SystemV4L2_treble_get", _wrap_SystemV4L2_treble_get, METH_O, "\n"
		"If V4L2 device supports audio, this integer property adjusts the audio treble.\n"
		"This property represents a V4L2-audio-control ID.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		"If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,\n"
		"values too large or too small will raise an exception.\n"
		""},
	 { "SystemV4L2_mute_get", _wrap_SystemV4L2_mute_get, METH_O, "\n"
		"If V4L2 device supports audio, this enumerated integer property sets audio mute on/off.\n"
		"This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "SystemV4L2_loudness_get", _wrap_SystemV4L2_loudness_get, METH_O, "\n"
		"If V4L2 device supports audio, this enumerated integer property sets audio loudness on/off.\n"
		"This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		"\n"
		"Notes: This property is not supported by every device.\n"
		"Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.\n"
		""},
	 { "delete_SystemV4L2", _wrap_delete_SystemV4L2, METH_O, NULL},
	 { "SystemV4L2_swigregister", SystemV4L2_swigregister, METH_O, NULL},
	 { "SystemV4L2_swiginit", SystemV4L2_swiginit, METH_VARARGS, NULL},
	 { "FirmwareUpdater_setTimeElapsed", _wrap_FirmwareUpdater_setTimeElapsed, METH_VARARGS, NULL},
	 { "new_FirmwareUpdater", _wrap_new_FirmwareUpdater, METH_VARARGS, "\n"
		" Creates a new **mvIMPACT::acquire::FirmwareUpdater** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type boForceOverideSameVersion: boolean\n"
		":param boForceOverideSameVersion: [in] A boolean value which defines if updates using the same version as installed on the camera should be allowed.\n"
		":type boForceDowngrade: boolean\n"
		":param boForceDowngrade: [in] A boolean value which defines if updates using an older version as installed on the camera should be allowed.\n"
		":type boKeepUserSets: boolean\n"
		":param boKeepUserSets: [in] A boolean value which defines if the user sets of the device will be kept or will be deleted during the update.\n"
		":type boForceBreakingChange: boolean\n"
		":param boForceBreakingChange: [in] A boolean value which defines if updates to versions which will deliver interface breaking changes will be allowed. Setting this value to ``true`` will also update a device which after the update might have a different interface. See documentation for additional information about breaking changes in firmware versions(there are not too many)!\n"
		""},
	 { "delete_FirmwareUpdater", _wrap_delete_FirmwareUpdater, METH_O, NULL},
	 { "FirmwareUpdater_onErrorMessage", _wrap_FirmwareUpdater_onErrorMessage, METH_VARARGS, "\n"
		" This function will be called once a message is waiting to be passed to the user.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::fuaContinue** if the current update shall continue.\n"
		"    - **mvIMPACT::acquire::fuaCancel** otherwise.\n"
		"\n"
		":type timeElapsed_s: float\n"
		":param timeElapsed_s: [in] The total time elapsed since starting the update process (in seconds).\n"
		""},
	 { "FirmwareUpdater_onErasingFlash", _wrap_FirmwareUpdater_onErasingFlash, METH_VARARGS, "\n"
		" This function will be called once the devices flash memory is erased.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		"\n"
		"Notes: Only some device types require this step so this callback might not be called for every device type.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::fuaContinue** if the current update shall continue.\n"
		"    - **mvIMPACT::acquire::fuaCancel** otherwise.\n"
		"\n"
		":type currentProgress_pc: int\n"
		":param currentProgress_pc: [in] The current progress of the erase operation (in percent).\n"
		":type timeElapsed_s: float\n"
		":param timeElapsed_s: [in] The total time elapsed since starting the update process (in seconds).\n"
		""},
	 { "FirmwareUpdater_onUnzippingFirmwareArchive", _wrap_FirmwareUpdater_onUnzippingFirmwareArchive, METH_VARARGS, "\n"
		" This function will be called once firmware archive (*.mvu) is unzipped to provide the correct firmware file.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::fuaContinue** if the current update shall continue.\n"
		"    - **mvIMPACT::acquire::fuaCancel** otherwise.\n"
		"\n"
		":type currentProgress_pc: int\n"
		":param currentProgress_pc: [in] The current progress of the unzip operation (in percent).\n"
		":type timeElapsed_s: float\n"
		":param timeElapsed_s: [in] The total time elapsed since starting the update process (in seconds).\n"
		""},
	 { "FirmwareUpdater_onUpdatingBootProgrammer", _wrap_FirmwareUpdater_onUpdatingBootProgrammer, METH_VARARGS, "\n"
		" This function will be called once the boot programmer of an mvBlueFOX3 camera is updated.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		"\n"
		"Notes: \n"
		"- Only mvBlueFOX3 cameras require this step so this callback might not be called in case of different device types.\n"
		"- BootProgrammer updates won't be necessary often, so this callback will not apply in every firmware update process.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::fuaContinue** if the current update shall continue.\n"
		"    - **mvIMPACT::acquire::fuaCancel** otherwise.\n"
		"\n"
		":type currentProgress_pc: int\n"
		":param currentProgress_pc: [in] The current progress of the update operation (in percent).\n"
		":type timeElapsed_s: float\n"
		":param timeElapsed_s: [in] The total time elapsed since starting the update process (in seconds).\n"
		""},
	 { "FirmwareUpdater_onUploadingImage", _wrap_FirmwareUpdater_onUploadingImage, METH_VARARGS, "\n"
		" This function will be called once the actual firmware file is uploaded to the device's flash memory.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		"\n"
		"Notes: \n"
		"- Depending on the device type this step might take a few seconds up to a few minutes.\n"
		"- The callback will be called several times during the upload.\n"
		"- Each time there was a progress of 5 percent this callback will be called.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::fuaContinue** if the current update shall continue.\n"
		"    - **mvIMPACT::acquire::fuaCancel** otherwise.\n"
		"\n"
		":type currentProgress_pc: int\n"
		":param currentProgress_pc: [in] The current progress of the upload operation (in percent).\n"
		":type timeElapsed_s: float\n"
		":param timeElapsed_s: [in] The total time elapsed since starting the update process (in seconds).\n"
		""},
	 { "FirmwareUpdater_onRebooting", _wrap_FirmwareUpdater_onRebooting, METH_VARARGS, "\n"
		" This function will be called once the device reboots to make sure the new firmware is applied to the device.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		"\n"
		"Notes: Returning **mvIMPACT::acquire::fuaCancel** on this callback will stop the upgrade process without rebooting the device. However, a new firmware is not active until a reboot or hard reset has been performed.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::fuaContinue** if the current update shall continue.\n"
		"    - **mvIMPACT::acquire::fuaCancel** otherwise.\n"
		"\n"
		":type currentProgress_pc: int\n"
		":param currentProgress_pc: [in] The current progress of the reboot operation (in percent).\n"
		":type timeElapsed_s: float\n"
		":param timeElapsed_s: [in] The total time elapsed since starting the update process (in seconds).\n"
		""},
	 { "FirmwareUpdater_onHardResetRequired", _wrap_FirmwareUpdater_onHardResetRequired, METH_VARARGS, "\n"
		" This function will be called once the device reboots and a manual hard reset is required.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		"\n"
		"Notes: If this function is called, a power cycle is inevitable. Otherwise the new firmware may be broken. The default is to stop the update at this point, so that the user can manually disconnect the power source.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::fuaContinue** if the current update shall continue.\n"
		"    - **mvIMPACT::acquire::fuaCancel** otherwise.\n"
		"\n"
		":type currentProgress_pc: int\n"
		":param currentProgress_pc: [in] The current progress of the reboot operation (in percent).\n"
		":type timeElapsed_s: float\n"
		":param timeElapsed_s: [in] The total time elapsed since starting the update process (in seconds).\n"
		""},
	 { "FirmwareUpdater_onSavingUserSets", _wrap_FirmwareUpdater_onSavingUserSets, METH_VARARGS, "\n"
		" This function will be called when the settings of the device are stored before updating the firmware.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		"\n"
		"This callback will only be called when user sets shall be available after the update. This can be specified by setting the **boKeepUserSets** flag upon construction of this object.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::fuaContinue** if the current update shall continue.\n"
		"    - **mvIMPACT::acquire::fuaCancel** otherwise.\n"
		"\n"
		":type currentProgress_pc: int\n"
		":param currentProgress_pc: [in] The current progress of the store operation (in percent).\n"
		":type timeElapsed_s: float\n"
		":param timeElapsed_s: [in] The total time elapsed since starting the update process (in seconds).\n"
		""},
	 { "FirmwareUpdater_onLoadingUserSets", _wrap_FirmwareUpdater_onLoadingUserSets, METH_VARARGS, "\n"
		" This function will be called when the settings of the device are written back after updating the firmware.\n"
		"Re-implement this function in a derived class in order to implement a custom behaviour.\n"
		"\n"
		"This callback will only be called when user sets shall be available after the update. This can be specified by setting the **boKeepUserSets** flag upon construction of this object.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::fuaContinue** if the current update shall continue.\n"
		"    - **mvIMPACT::acquire::fuaCancel** otherwise.\n"
		"\n"
		":type currentProgress_pc: int\n"
		":param currentProgress_pc: [in] The current progress of the load operation (in percent).\n"
		":type timeElapsed_s: float\n"
		":param timeElapsed_s: [in] The total time elapsed since starting the update process (in seconds).\n"
		""},
	 { "FirmwareUpdater_update", _wrap_FirmwareUpdater_update, METH_VARARGS, "\n"
		" A function to start the firmware update process.\n"
		"This function is intended to be used to update MATRIX VISION imaging and image capture devices.\n"
		"Notes: \n"
		"- Once this function returns, the device will be closed! All objects previously created using the **mvIMPACT::acquire::Device** pointer must be recreated then.\n"
		"- For mvBlueFOX device this function needs to be called **without** passing any parameters to the function!\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **::TDMR_ERROR** otherwise.\n"
		"\n"
		":type archivePath: string\n"
		":param archivePath: [in] Path to the file which should be used to update the device. Can be empty if no update archives are needed for the device.\n"
		":type boUpdateDataAsNeeded: boolean\n"
		":param boUpdateDataAsNeeded: [in] Can be set to false in order to save time when updating multiple devices in one go. Please note that as soon as at least one GenICam device is part of these multiple devices either **mvIMPACT::acquire::DeviceManager::updateDeviceList** **must** be called **or** every instance to mvIMPACT::acquire::DeviceManager in the current process needs to be destroyed afterwards before any of those GenICam devices can be used again!\n"
		""},
	 { "FirmwareUpdater_statusMessage", _wrap_FirmwareUpdater_statusMessage, METH_O, " Returns the current status from the status property"},
	 { "FirmwareUpdater_getTimeElapsed", _wrap_FirmwareUpdater_getTimeElapsed, METH_O, "\n"
		" A method to receive the time in seconds since the update process has been started\n"
		":rtype: float\n"
		":return: The time elapsed since the firmware update currently running has been started.\n"
		""},
	 { "FirmwareUpdater_verifyFirmwareChecksum", _wrap_FirmwareUpdater_verifyFirmwareChecksum, METH_VARARGS, "\n"
		" A function to check the integrity of the firmware running on a device.\n"
		"This function is intended to be used to check the firmware integrity of MATRIX VISION imaging and image capture devices only.\n"
		"Most MATRIX VISION imaging and image capture devices are capable of calculating a hash from the firmware image which is currently running on the device. In addition to\n"
		"that firmware archives for imaging devices provided by MATRIX VISION contain hashes for all the firmware images contained in the update archive. Comparing these\n"
		"2 hashes will provide additional security when an application wants to make sure that the firmware running on the device is undamaged.\n"
		"\n"
		"Notes: \n"
		"- When calling this function, the firmware archive path passed to it must contain the exact same firmware that is running on the\n"
		"device.\n"
		"- This feature is currently only available for most MATRIX VISION GenICam compliant devices.\n"
		"- Once this function returns, the device will be closed! All objects previously created using the mvIMPACT::acquire::Device pointer must be recreated then.\n"
		"- If the function returns a negative code of type **mvIMPACT::acquire::TDMR_ERROR**, the status string will contain a more specific explanation about the root cause for the issue.\n"
		"\n"
		"Since: 2.47.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - A negative error code of type **::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type archivePath: string\n"
		":param archivePath: [in] Path to the file which should be used to compare the firmware checksum from with the firmware currently running on the device.\n"
		":type pStatusMessage: string\n"
		":param pStatusMessage: [out] Pointer to a string receiving additional information about the outcome of the operation. This can be 0 if no one is interested in status information.\n"
		""},
	 { "FirmwareUpdater_firmwareVersionToUpload_get", _wrap_FirmwareUpdater_firmwareVersionToUpload_get, METH_O, "\n"
		" An enumerated integer property containing a list of available firmware versions.\n"
		"Notes: \n"
		"This feature currently is only available for **mvBlueFOX** devices since here the firmware is part of the driver library.\n"
		"So no additional archive is needed, but the desired firmware version to upload into the device's non-volatile memory can\n"
		"be selected by writing to this property before calling the **mvIMPACT::acquire::FirmwareUpdater::update** function.\n"
		""},
	 { "disown_FirmwareUpdater", _wrap_disown_FirmwareUpdater, METH_O, NULL},
	 { "FirmwareUpdater_swigregister", FirmwareUpdater_swigregister, METH_O, NULL},
	 { "FirmwareUpdater_swiginit", FirmwareUpdater_swiginit, METH_VARARGS, NULL},
	 { "new_GenTLProducerConfiguration", _wrap_new_GenTLProducerConfiguration, METH_O, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** from an existing one.\n"
		":type src: :py:class:`GenTLProducerConfiguration`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** object, this object shall be created from\n"
		""},
	 { "GenTLProducerConfiguration_enumerationEnable_get", _wrap_GenTLProducerConfiguration_enumerationEnable_get, METH_O, "\n"
		" An enumerated integer property defining the enumeration behavior this particular GenTL producer.\n"
		"If this property is set to **mvIMPACT::acquire::bTrue** ALL interfaces of this producer will be enumerated\n"
		"unless a specific interface enumeration behaviour has been set to **mvIMPACT::acquire::iebForceIgnore**.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.\n"
		""},
	 { "GenTLProducerConfiguration_getInterfaceEnumerationBehaviour", _wrap_GenTLProducerConfiguration_getInterfaceEnumerationBehaviour, METH_VARARGS, "\n"
		" Returns the interface enumeration behaviour property for the specified interface ID for this particular GenTL producer.\n"
		"\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInterfaceEnumerationBehaviour**.\n"
		"\n"
		"Notes: If no entry for the specified interface ID exists an exception will be thrown.\n"
		"\n"
		":rtype: :py:class:`PropertyIInterfaceEnumerationBehaviour`\n"
		":return: The enumeration behaviour configuration property for the specified interface\n"
		"\n"
		":type interfaceID: string\n"
		":param interfaceID: [in] The interface ID previously passed e.g. to the **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration::createProducerInterfaceConfigurationEntry** function.\n"
		""},
	 { "GenTLProducerConfiguration_getInterfaceEnumerationBehaviours", _wrap_GenTLProducerConfiguration_getInterfaceEnumerationBehaviours, METH_O, "\n"
		" Returns a map containing all the configured interface IDs and their corresponding enumeration behaviour properties for this particular GenTL producer.\n"
		"The returned map will only contain interface IDs which have explicitly been configured (e.g. by a previous call to\n"
		"**mvIMPACT::acquire::GenICam::GenTLProducerConfiguration::createProducerInterfaceConfigurationEntry**. Certain third party\n"
		"interfaces might also have an entry in this map (e.g. if there is a MATRIX VISION GenICam GenTL producer supporting the same technology present\n"
		"on the system).\n"
		"\n"
		"Valid values for the properties are defined by the enumeration **mvIMPACT::acquire::TInterfaceEnumerationBehaviour**.\n"
		"\n"
		":rtype: std::map< std::string,mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour >\n"
		":return: A map containing all the configured interface IDs and their corresponding enumeration behaviour properties for this particular GenTL producer\n"
		""},
	 { "GenTLProducerConfiguration_createProducerInterfaceConfigurationEntry", _wrap_GenTLProducerConfiguration_createProducerInterfaceConfigurationEntry, METH_VARARGS, "\n"
		" Creates a new interface configuration entry for this producers configuration.\n"
		"Usually the parameter passed to this function will be one of the interface IDs of the producers list of reported interfaces\n"
		"in order to configure this particular interface. However it can also be an identifier for an interface not yet connected to the\n"
		"system or not yet available to the producer. No internal checks are performed regarding the validity of the given interface ID.\n"
		"\n"
		"Notes: If an entry with the same interface ID already exists an exception will be thrown.\n"
		"\n"
		":type interfaceID: string\n"
		":param interfaceID: [in] The interface ID to create the configuration entry for.\n"
		""},
	 { "GenTLProducerConfiguration_deleteProducerInterfaceConfigurationEntry", _wrap_GenTLProducerConfiguration_deleteProducerInterfaceConfigurationEntry, METH_VARARGS, "\n"
		" Deletes an interface configuration entry from this producers configuration.\n"
		"Notes: If no entry for the specified interface can be found an exception will be thrown.\n"
		"\n"
		":type interfaceID: string\n"
		":param interfaceID: [in] The exact interface ID of the producers list of reported interfaces to delete the configuration entry for.\n"
		""},
	 { "GenTLProducerConfiguration_getProducerName", _wrap_GenTLProducerConfiguration_getProducerName, METH_O, "\n"
		" Returns the name of the GenTL producer associated with this configuration object.\n"
		":rtype: string\n"
		":return: The name of the GenTL producer associated with this configuration object.\n"
		""},
	 { "delete_GenTLProducerConfiguration", _wrap_delete_GenTLProducerConfiguration, METH_O, NULL},
	 { "GenTLProducerConfiguration_swigregister", GenTLProducerConfiguration_swigregister, METH_O, NULL},
	 { "GenTLProducerConfiguration_swiginit", GenTLProducerConfiguration_swiginit, METH_VARARGS, NULL},
	 { "new_GenTLDriverConfigurator", _wrap_new_GenTLDriverConfigurator, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator** from an existing one.\n"
		":type src: :py:class:`GenTLDriverConfigurator`\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator** object, this object shall be created from\n"
		""},
	 { "GenTLDriverConfigurator_masterEnumerationBehaviour_get", _wrap_GenTLDriverConfigurator_masterEnumerationBehaviour_get, METH_O, "\n"
		" An enumerated integer property defining the master enumeration mode for all GenTL producer detected in the current session.\n"
		"Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInterfaceEnumerationBehaviour**.\n"
		""},
	 { "GenTLDriverConfigurator_createProducerConfiguration", _wrap_GenTLDriverConfigurator_createProducerConfiguration, METH_VARARGS, "\n"
		" Creates a new **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** object for the desired interface reported by the specified producer.\n"
		"Calling this function will creates a new **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** object for the desired interface\n"
		"reported by the specified producer.\n"
		"\n"
		"Notes: If a configuration entry for the specified interface does already exist an exception will be thrown.\n"
		"\n"
		":type producerName: string\n"
		":param producerName: [in] The exact name of the producer library without the path to create the entry for.\n"
		":type interfaceID: string\n"
		":param interfaceID: [in] The interface ID to create the configuration entry for.\n"
		""},
	 { "GenTLDriverConfigurator_deleteProducerConfiguration", _wrap_GenTLDriverConfigurator_deleteProducerConfiguration, METH_VARARGS, "\n"
		" Deletes a **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects.\n"
		"Calling this function will delete the **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** object for the referenced producer.\n"
		"\n"
		"Notes: If no entry for the specified producer can be found an exception will be thrown.\n"
		"\n"
		":type producerName: string\n"
		":param producerName: [in] The exact name of the producer library without the path to delete the entry from.\n"
		""},
	 { "GenTLDriverConfigurator_deleteAllProducerConfigurations", _wrap_GenTLDriverConfigurator_deleteAllProducerConfigurations, METH_O, "\n"
		" Deletes all **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects.\n"
		"Calling this function will result in all **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects to be deleted. When the next\n"
		"mvIMPACT Acquire process will be started after shutting down the current one all producer libraries found on the system will be processed. By default only interfaces reporting\n"
		"types/technologies (e.g. GigE Vision) also supported by MATRIX VISION will be ignored (will not enumerate devices) then.\n"
		""},
	 { "GenTLDriverConfigurator_hasProducerConfiguration", _wrap_GenTLDriverConfigurator_hasProducerConfiguration, METH_VARARGS, "\n"
		" Checks if a certain producer library has been associated with a **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration**.\n"
		":rtype: boolean\n"
		":return: \n"
		"    - true if a **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** is currently associated with the referenced producer library\n"
		"    - false otherwise\n"
		"\n"
		":type producerName: string\n"
		":param producerName: [in] The exact name of the producer library without the path.\n"
		""},
	 { "GenTLDriverConfigurator_getProducerConfiguration", _wrap_GenTLDriverConfigurator_getProducerConfiguration, METH_VARARGS, "\n"
		" Returns the **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** associated with the referenced producer library.\n"
		"\n"
		"Notes: If no entry for the specified producer can be found an exception will be thrown.\n"
		"\n"
		":rtype: :py:class:`GenTLProducerConfiguration`\n"
		":return: The **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** associated with the referenced producer library.\n"
		"\n"
		":type producerName: string\n"
		":param producerName: [in] The exact name of the producer library without the path.\n"
		""},
	 { "GenTLDriverConfigurator_getProducerConfigurations", _wrap_GenTLDriverConfigurator_getProducerConfigurations, METH_O, "\n"
		" Returns a vector containing all **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects currently defined.\n"
		":rtype: std::vector< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration,std::allocator< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration > >\n"
		":return: A vector containing all **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects currently defined.\n"
		""},
	 { "delete_GenTLDriverConfigurator", _wrap_delete_GenTLDriverConfigurator, METH_O, NULL},
	 { "GenTLDriverConfigurator_swigregister", GenTLDriverConfigurator_swigregister, METH_O, NULL},
	 { "GenTLDriverConfigurator_swiginit", GenTLDriverConfigurator_swiginit, METH_VARARGS, NULL},
	 { "new_VideoStream", _wrap_new_VideoStream, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Creates a new video stream file.\n"
		"Notes: \n"
		"Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries\n"
		"cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented\n"
		":type pBuffer: :py:class:`ImageBuffer`\n"
		":param pBuffer: [in] An image buffer containing the layout of the images that are about to get stored in the stream. This structure can be extracted from a real **mvIMPACT::acquire::Request** object captured previously but **NOT** by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely.The latter one will not contain all the information needed for a successful stream creation. You could even create a stream from a list of files e.g. on a hard-disc using the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name. If you want to use the **mvIMPACT::acquire::Request** object obtained from a call to **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** use the constructor accepting a **mvIMPACT::acquire::Request** pointer!\n"
		":type codec: int\n"
		":param codec: [in] The codec that shall be used while encoding the images into the stream.\n"
		":type quality_pc: int\n"
		":param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**.\n"
		":type bitrate: int\n"
		":param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Creates a new video stream file.\n"
		"Notes: \n"
		"Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries\n"
		"cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented\n"
		":type imageWidth: int\n"
		":param imageWidth: [in] The input image width in pixels\n"
		":type imageHeight: int\n"
		":param imageHeight: [in] The input image height in pixels\n"
		":type codec: int\n"
		":param codec: [in] The codec that shall be used while encoding the images into the stream.\n"
		":type quality_pc: int\n"
		":param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**.\n"
		":type bitrate: int\n"
		":param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Creates a new video stream file.\n"
		"Notes: \n"
		"Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries\n"
		"cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented\n"
		":type imageWidth: int\n"
		":param imageWidth: [in] The input image width in pixels\n"
		":type imageHeight: int\n"
		":param imageHeight: [in] The input image height in pixels\n"
		":type codec: int\n"
		":param codec: [in] The codec that shall be used while encoding the images into the stream.\n"
		":type quality_pc: int\n"
		":param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**.\n"
		":param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Creates a new video stream file.\n"
		"Notes: \n"
		"Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries\n"
		"cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented\n"
		":type imageWidth: int\n"
		":param imageWidth: [in] The input image width in pixels\n"
		":type imageHeight: int\n"
		":param imageHeight: [in] The input image height in pixels\n"
		":type codec: int\n"
		":param codec: [in] The codec that shall be used while encoding the images into the stream.\n"
		":param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**.\n"
		":param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Creates a new video stream file.\n"
		"Notes: \n"
		"Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries\n"
		"cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented\n"
		":type imageWidth: int\n"
		":param imageWidth: [in] The input image width in pixels\n"
		":type imageHeight: int\n"
		":param imageHeight: [in] The input image height in pixels\n"
		":param codec: [in] The codec that shall be used while encoding the images into the stream.\n"
		":param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**.\n"
		":param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Creates a new video stream file.\n"
		"Notes: \n"
		"Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries\n"
		"cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented.\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A **mvIMPACT::acquire::Request** object carrying the image related information that are about to get stored in the stream. This can either be extracted from a real **mvIMPACT::acquire::Request** object captured previously or by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely. To create a stream from a list of files e.g. on a hard-disc use the **mvIMPACT::acquire::labs::VideoStream** constructor accepting a **mvIMPACT::acquire::ImageBufferDesc** instead! Create instances of b mvIMPACT::acquire::ImageBufferDesc objects from files call the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name.\n"
		":type codec: int\n"
		":param codec: [in] The codec that shall be used while encoding the images into the stream.\n"
		":type quality_pc: int\n"
		":param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**.\n"
		":type bitrate: int\n"
		":param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Creates a new video stream file.\n"
		"Notes: \n"
		"Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries\n"
		"cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented.\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A **mvIMPACT::acquire::Request** object carrying the image related information that are about to get stored in the stream. This can either be extracted from a real **mvIMPACT::acquire::Request** object captured previously or by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely. To create a stream from a list of files e.g. on a hard-disc use the **mvIMPACT::acquire::labs::VideoStream** constructor accepting a **mvIMPACT::acquire::ImageBufferDesc** instead! Create instances of b mvIMPACT::acquire::ImageBufferDesc objects from files call the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name.\n"
		":type codec: int\n"
		":param codec: [in] The codec that shall be used while encoding the images into the stream.\n"
		":type quality_pc: int\n"
		":param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**.\n"
		":param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 8:*\n"
		" Creates a new video stream file.\n"
		"Notes: \n"
		"Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries\n"
		"cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented.\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A **mvIMPACT::acquire::Request** object carrying the image related information that are about to get stored in the stream. This can either be extracted from a real **mvIMPACT::acquire::Request** object captured previously or by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely. To create a stream from a list of files e.g. on a hard-disc use the **mvIMPACT::acquire::labs::VideoStream** constructor accepting a **mvIMPACT::acquire::ImageBufferDesc** instead! Create instances of b mvIMPACT::acquire::ImageBufferDesc objects from files call the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name.\n"
		":type codec: int\n"
		":param codec: [in] The codec that shall be used while encoding the images into the stream.\n"
		":param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**.\n"
		":param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 9:*\n"
		" Creates a new video stream file.\n"
		"Notes: \n"
		"Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries\n"
		"cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.\n"
		"\n"
		":type fileName: string\n"
		":param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented.\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A **mvIMPACT::acquire::Request** object carrying the image related information that are about to get stored in the stream. This can either be extracted from a real **mvIMPACT::acquire::Request** object captured previously or by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely. To create a stream from a list of files e.g. on a hard-disc use the **mvIMPACT::acquire::labs::VideoStream** constructor accepting a **mvIMPACT::acquire::ImageBufferDesc** instead! Create instances of b mvIMPACT::acquire::ImageBufferDesc objects from files call the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name.\n"
		":param codec: [in] The codec that shall be used while encoding the images into the stream.\n"
		":param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**.\n"
		":param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.\n"
		""},
	 { "delete_VideoStream", _wrap_delete_VideoStream, METH_O, NULL},
	 { "VideoStream_getFileName", _wrap_VideoStream_getFileName, METH_O, "\n"
		" Returns the file name of this video stream.\n"
		"This function returns the file name of this video stream.\n"
		"\n"
		"Since: 2.39.0\n"
		"\n"
		" :rtype: string\n"
		" :return: The file name of this video stream.\n"
		""},
	 { "VideoStream_getCodec", _wrap_VideoStream_getCodec, METH_O, "\n"
		" Returns the codec used by this video stream.\n"
		"This function returns the codec used by this video stream.\n"
		"\n"
		"Since: 2.39.0\n"
		"\n"
		" :rtype: int\n"
		" :return: The codec used by this video stream.\n"
		""},
	 { "VideoStream_getCodecAsString", _wrap_VideoStream_getCodecAsString, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Returns the a string representation for a video codec.\n"
		"This function returns a string representation for a video codec.\n"
		"\n"
		"Since: 2.39.0\n"
		"\n"
		" :rtype: string\n"
		" :return: A string representation for a video codec.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Returns the codec used by this video stream as a string.\n"
		"This function returns the codec used by this video stream as a string.\n"
		"\n"
		"Since: 2.39.0\n"
		"\n"
		" :rtype: string\n"
		" :return: The codec used by this video stream as a string.\n"
		""},
	 { "VideoStream_isAPIAvailable", _wrap_VideoStream_isAPIAvailable, METH_NOARGS, "\n"
		" Checks if the video stream API is available.\n"
		"This function checks if the video stream API is available.\n"
		"\n"
		"Since: 2.39.0\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"     - true if the video stream API is available thus video streams can be created\n"
		"     - false otherwise.\n"
		""},
	 { "VideoStream_saveImage", _wrap_VideoStream_saveImage, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Stores an image into the video stream.\n"
		" This function stores an image into the video stream.\n"
		"\n"
		" Notes: \n"
		" Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section as well as the remarks made here: **mvIMPACT::acquire::labs::VideoStream)** is used for this operation. If the corresponding libraries\n"
		" cannot be located in one of the supported versions on the host system calling this function will fail.\n"
		"\n"
		"Since: 2.39.0\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DMR_LIBRARY_NOT_FOUND** if no compatible version of the FFmpeg libraries could be located on the host system.\n"
		"     - **mvIMPACT::acquire::DEV_UNSUPPORTED_PARAMETER** if a pixel format has been passed to the function that is not supported by the internal algorithms.\n"
		"     - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** e.g. if a pixel format has been passed to the function that is not supported by the FFmpeg libraries.\n"
		"     - A negative error code of type **::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pBuffer: :py:class:`ImageBuffer`\n"
		":param pBuffer: [in] The image to encode and store.\n"
		":type timestamp_us: int\n"
		":param timestamp_us: [in] A timestamp(in us) to associate this image with. This can be 0 if no timestamp is available.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Encodes and stores the image associated with the **mvIMPACT::acquire::Request** object into the stream.\n"
		" This function stores the image associated with an **mvIMPACT::acquire::Request** object into the video stream.\n"
		"\n"
		" Notes: \n"
		" Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section as well as the remarks made here: **mvIMPACT::acquire::labs::VideoStream)** is used for this operation. If the corresponding libraries\n"
		" cannot be located in one of the supported versions on the host system calling this function will fail.\n"
		"\n"
		"Since: 2.39.0\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::labs::VideoStream::pause**,\n"
		"\n"
		" **mvIMPACT::acquire::labs::VideoStream::isPaused**,\n"
		"\n"
		" **mvIMPACT::acquire::labs::VideoStream::resume**\n"
		"\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DMR_LIBRARY_NOT_FOUND** if no compatible version of the FFmpeg libraries could be located on the host system.\n"
		"     - **mvIMPACT::acquire::DEV_UNSUPPORTED_PARAMETER** if a pixel format has been passed to the function that is not supported by the internal algorithms.\n"
		"     - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** e.g. if a pixel format has been passed to the function that is not supported by the FFmpeg libraries.\n"
		"     - A negative error code of type **::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to the **mvIMPACT::acquire::Request** object carrying the image to encode and store.\n"
		""},
	 { "VideoStream_pause", _wrap_VideoStream_pause, METH_O, "\n"
		" Pauses this video stream.\n"
		" This function pauses this video stream. While paused no images can be written into the stream. Pausing internally simply starts a timer\n"
		" and all accumulated pause times will be subtracted from images that will be written into the stream after the pause has been ended effectively\n"
		" allowing to remove inactive sections from the video stream.\n"
		"\n"
		" Notes: \n"
		" Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section as well as the remarks made here: **mvIMPACT::acquire::labs::VideoStream)** is used for this operation. If the corresponding libraries\n"
		" cannot be located in one of the supported versions on the host system calling this function will fail.\n"
		"\n"
		"Since: 2.41.0\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::labs::VideoStream::resume**,\n"
		"\n"
		" **mvIMPACT::acquire::labs::VideoStream::isPaused**\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DMR_BUSY** if this stream has been paused already.\n"
		"     - A negative error code of type **::TDMR_ERROR** otherwise.\n"
		""},
	 { "VideoStream_isPaused", _wrap_VideoStream_isPaused, METH_O, "\n"
		" Checks is this video stream is currently paused.\n"
		"\n"
		" Notes: \n"
		" Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section as well as the remarks made here: **mvIMPACT::acquire::labs::VideoStream)** is used for this operation. If the corresponding libraries\n"
		" cannot be located in one of the supported versions on the host system calling this function will fail.\n"
		"\n"
		"Since: 2.41.0\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::labs::VideoStream::pause**,\n"
		"\n"
		" **mvIMPACT::acquire::labs::VideoStream::resume**\n"
		"\n"
		" :rtype: boolean\n"
		" :return: \n"
		"     - true if this video stream is currently paused.\n"
		"     - false otherwise.\n"
		""},
	 { "VideoStream_resume", _wrap_VideoStream_resume, METH_O, "\n"
		" Resumes this video stream.\n"
		" This function resumes this previously paused video stream. While paused no images can be written into the stream. Pausing internally simply starts a timer\n"
		" and all accumulated pause times will be subtracted from images that will be written into the stream after the pause has been ended effectively\n"
		" allowing to remove inactive sections from the video stream.\n"
		"\n"
		" Notes: \n"
		" Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section as well as the remarks made here: **mvIMPACT::acquire::labs::VideoStream)** is used for this operation. If the corresponding libraries\n"
		" cannot be located in one of the supported versions on the host system calling this function will fail.\n"
		"\n"
		"Since: 2.41.0\n"
		"\n"
		" See also: \n"
		" **mvIMPACT::acquire::labs::VideoStream::pause**,\n"
		"\n"
		" **mvIMPACT::acquire::labs::VideoStream::isPaused**\n"
		"\n"
		" :rtype: int\n"
		" :return: \n"
		"     - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"     - **mvIMPACT::acquire::DMR_EXECUTION_PROHIBITED** if this stream has been paused already.\n"
		"     - A negative error code of type **::TDMR_ERROR** otherwise.\n"
		""},
	 { "VideoStream_swigregister", VideoStream_swigregister, METH_O, NULL},
	 { "VideoStream_swiginit", VideoStream_swiginit, METH_VARARGS, NULL},
	 { "new_VideoStreamPauseScope", _wrap_new_VideoStreamPauseScope, METH_VARARGS, "\n"
		" Creates a new **mvIMPACT::acquire::labs::VideoStreamPauseScope** object.\n"
		"Trying to pause a stream that is paused already or trying to resume a stream that is not paused will raise an exception!\n"
		"When this object goes out of scope the previous state will be restored automatically.\n"
		"\n"
		":type stream: :py:class:`VideoStream`\n"
		":param stream: [in] The video stream that shall be configured.\n"
		":type boPausedWithinScope: boolean\n"
		":param boPausedWithinScope: [in] The mode the selected video stream shall have while this object is alive.\n"
		""},
	 { "delete_VideoStreamPauseScope", _wrap_delete_VideoStreamPauseScope, METH_O, NULL},
	 { "VideoStreamPauseScope_swigregister", VideoStreamPauseScope_swigregister, METH_O, NULL},
	 { "VideoStreamPauseScope_swiginit", VideoStreamPauseScope_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyI", _wrap_new_PropertyI, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< int >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyI_getTranslationDict", _wrap_PropertyI_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< int >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,int >,std::allocator< std::pair< std::string,int > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyI_getTranslationDictString", _wrap_PropertyI_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyI_getTranslationDictValue", _wrap_PropertyI_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyI_getTranslationDictStrings", _wrap_PropertyI_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< int >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyI_getTranslationDictValues", _wrap_PropertyI_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< int >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyI_getMaxValue", _wrap_PropertyI_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI_getMinValue", _wrap_PropertyI_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI_getStepWidth", _wrap_PropertyI_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI_read", _wrap_PropertyI_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyI_write", _wrap_PropertyI_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< int >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< int >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< int >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< int >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< int >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< int,std::allocator< int > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyI", _wrap_delete_PropertyI, METH_O, NULL},
	 { "PropertyI_swigregister", PropertyI_swigregister, METH_O, NULL},
	 { "PropertyI_swiginit", PropertyI_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringint", _wrap_new_pairstringint, METH_VARARGS, NULL},
	 { "pairstringint_first_set", _wrap_pairstringint_first_set, METH_VARARGS, NULL},
	 { "pairstringint_first_get", _wrap_pairstringint_first_get, METH_O, NULL},
	 { "pairstringint_second_set", _wrap_pairstringint_second_set, METH_VARARGS, NULL},
	 { "pairstringint_second_get", _wrap_pairstringint_second_get, METH_O, NULL},
	 { "delete_pairstringint", _wrap_delete_pairstringint, METH_O, NULL},
	 { "pairstringint_swigregister", pairstringint_swigregister, METH_O, NULL},
	 { "pairstringint_swiginit", pairstringint_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIAcquisitionField", _wrap_new_PropertyIAcquisitionField, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIAcquisitionField_getTranslationDict", _wrap_PropertyIAcquisitionField_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIAcquisitionField_getTranslationDictString", _wrap_PropertyIAcquisitionField_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAcquisitionField_getTranslationDictValue", _wrap_PropertyIAcquisitionField_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAcquisitionField_getTranslationDictStrings", _wrap_PropertyIAcquisitionField_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAcquisitionField_getTranslationDictValues", _wrap_PropertyIAcquisitionField_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAcquisitionField_getMaxValue", _wrap_PropertyIAcquisitionField_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAcquisitionField_getMinValue", _wrap_PropertyIAcquisitionField_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAcquisitionField_getStepWidth", _wrap_PropertyIAcquisitionField_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAcquisitionField_read", _wrap_PropertyIAcquisitionField_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIAcquisitionField_write", _wrap_PropertyIAcquisitionField_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIAcquisitionField", _wrap_delete_PropertyIAcquisitionField, METH_O, NULL},
	 { "PropertyIAcquisitionField_swigregister", PropertyIAcquisitionField_swigregister, METH_O, NULL},
	 { "PropertyIAcquisitionField_swiginit", PropertyIAcquisitionField_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTAcquisitionField", _wrap_new_pairstringTAcquisitionField, METH_VARARGS, NULL},
	 { "pairstringTAcquisitionField_first_set", _wrap_pairstringTAcquisitionField_first_set, METH_VARARGS, NULL},
	 { "pairstringTAcquisitionField_first_get", _wrap_pairstringTAcquisitionField_first_get, METH_O, NULL},
	 { "pairstringTAcquisitionField_second_set", _wrap_pairstringTAcquisitionField_second_set, METH_VARARGS, NULL},
	 { "pairstringTAcquisitionField_second_get", _wrap_pairstringTAcquisitionField_second_get, METH_O, NULL},
	 { "delete_pairstringTAcquisitionField", _wrap_delete_pairstringTAcquisitionField, METH_O, NULL},
	 { "pairstringTAcquisitionField_swigregister", pairstringTAcquisitionField_swigregister, METH_O, NULL},
	 { "pairstringTAcquisitionField_swiginit", pairstringTAcquisitionField_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIAcquisitionMode", _wrap_new_PropertyIAcquisitionMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIAcquisitionMode_getTranslationDict", _wrap_PropertyIAcquisitionMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIAcquisitionMode_getTranslationDictString", _wrap_PropertyIAcquisitionMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAcquisitionMode_getTranslationDictValue", _wrap_PropertyIAcquisitionMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAcquisitionMode_getTranslationDictStrings", _wrap_PropertyIAcquisitionMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAcquisitionMode_getTranslationDictValues", _wrap_PropertyIAcquisitionMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAcquisitionMode_getMaxValue", _wrap_PropertyIAcquisitionMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAcquisitionMode_getMinValue", _wrap_PropertyIAcquisitionMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAcquisitionMode_getStepWidth", _wrap_PropertyIAcquisitionMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAcquisitionMode_read", _wrap_PropertyIAcquisitionMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIAcquisitionMode_write", _wrap_PropertyIAcquisitionMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIAcquisitionMode", _wrap_delete_PropertyIAcquisitionMode, METH_O, NULL},
	 { "PropertyIAcquisitionMode_swigregister", PropertyIAcquisitionMode_swigregister, METH_O, NULL},
	 { "PropertyIAcquisitionMode_swiginit", PropertyIAcquisitionMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTAcquisitionMode", _wrap_new_pairstringTAcquisitionMode, METH_VARARGS, NULL},
	 { "pairstringTAcquisitionMode_first_set", _wrap_pairstringTAcquisitionMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTAcquisitionMode_first_get", _wrap_pairstringTAcquisitionMode_first_get, METH_O, NULL},
	 { "pairstringTAcquisitionMode_second_set", _wrap_pairstringTAcquisitionMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTAcquisitionMode_second_get", _wrap_pairstringTAcquisitionMode_second_get, METH_O, NULL},
	 { "delete_pairstringTAcquisitionMode", _wrap_delete_pairstringTAcquisitionMode, METH_O, NULL},
	 { "pairstringTAcquisitionMode_swigregister", pairstringTAcquisitionMode_swigregister, METH_O, NULL},
	 { "pairstringTAcquisitionMode_swiginit", pairstringTAcquisitionMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIAcquisitionStartStopBehaviour", _wrap_new_PropertyIAcquisitionStartStopBehaviour, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_getTranslationDict", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_getTranslationDictString", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_getTranslationDictValues", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_getMaxValue", _wrap_PropertyIAcquisitionStartStopBehaviour_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_getMinValue", _wrap_PropertyIAcquisitionStartStopBehaviour_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_getStepWidth", _wrap_PropertyIAcquisitionStartStopBehaviour_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_read", _wrap_PropertyIAcquisitionStartStopBehaviour_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIAcquisitionStartStopBehaviour_write", _wrap_PropertyIAcquisitionStartStopBehaviour_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIAcquisitionStartStopBehaviour", _wrap_delete_PropertyIAcquisitionStartStopBehaviour, METH_O, NULL},
	 { "PropertyIAcquisitionStartStopBehaviour_swigregister", PropertyIAcquisitionStartStopBehaviour_swigregister, METH_O, NULL},
	 { "PropertyIAcquisitionStartStopBehaviour_swiginit", PropertyIAcquisitionStartStopBehaviour_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTAcquisitionStartStopBehaviour", _wrap_new_pairstringTAcquisitionStartStopBehaviour, METH_VARARGS, NULL},
	 { "pairstringTAcquisitionStartStopBehaviour_first_set", _wrap_pairstringTAcquisitionStartStopBehaviour_first_set, METH_VARARGS, NULL},
	 { "pairstringTAcquisitionStartStopBehaviour_first_get", _wrap_pairstringTAcquisitionStartStopBehaviour_first_get, METH_O, NULL},
	 { "pairstringTAcquisitionStartStopBehaviour_second_set", _wrap_pairstringTAcquisitionStartStopBehaviour_second_set, METH_VARARGS, NULL},
	 { "pairstringTAcquisitionStartStopBehaviour_second_get", _wrap_pairstringTAcquisitionStartStopBehaviour_second_get, METH_O, NULL},
	 { "delete_pairstringTAcquisitionStartStopBehaviour", _wrap_delete_pairstringTAcquisitionStartStopBehaviour, METH_O, NULL},
	 { "pairstringTAcquisitionStartStopBehaviour_swigregister", pairstringTAcquisitionStartStopBehaviour_swigregister, METH_O, NULL},
	 { "pairstringTAcquisitionStartStopBehaviour_swiginit", pairstringTAcquisitionStartStopBehaviour_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIAoiMode", _wrap_new_PropertyIAoiMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIAoiMode_getTranslationDict", _wrap_PropertyIAoiMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAoiMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAoiMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIAoiMode_getTranslationDictString", _wrap_PropertyIAoiMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAoiMode_getTranslationDictValue", _wrap_PropertyIAoiMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAoiMode_getTranslationDictStrings", _wrap_PropertyIAoiMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAoiMode_getTranslationDictValues", _wrap_PropertyIAoiMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAoiMode_getMaxValue", _wrap_PropertyIAoiMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAoiMode_getMinValue", _wrap_PropertyIAoiMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAoiMode_getStepWidth", _wrap_PropertyIAoiMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAoiMode_read", _wrap_PropertyIAoiMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIAoiMode_write", _wrap_PropertyIAoiMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIAoiMode", _wrap_delete_PropertyIAoiMode, METH_O, NULL},
	 { "PropertyIAoiMode_swigregister", PropertyIAoiMode_swigregister, METH_O, NULL},
	 { "PropertyIAoiMode_swiginit", PropertyIAoiMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTAoiMode", _wrap_new_pairstringTAoiMode, METH_VARARGS, NULL},
	 { "pairstringTAoiMode_first_set", _wrap_pairstringTAoiMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTAoiMode_first_get", _wrap_pairstringTAoiMode_first_get, METH_O, NULL},
	 { "pairstringTAoiMode_second_set", _wrap_pairstringTAoiMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTAoiMode_second_get", _wrap_pairstringTAoiMode_second_get, METH_O, NULL},
	 { "delete_pairstringTAoiMode", _wrap_delete_pairstringTAoiMode, METH_O, NULL},
	 { "pairstringTAoiMode_swigregister", pairstringTAoiMode_swigregister, METH_O, NULL},
	 { "pairstringTAoiMode_swiginit", pairstringTAoiMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIAutoControlSpeed", _wrap_new_PropertyIAutoControlSpeed, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIAutoControlSpeed_getTranslationDict", _wrap_PropertyIAutoControlSpeed_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIAutoControlSpeed_getTranslationDictString", _wrap_PropertyIAutoControlSpeed_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoControlSpeed_getTranslationDictValue", _wrap_PropertyIAutoControlSpeed_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoControlSpeed_getTranslationDictStrings", _wrap_PropertyIAutoControlSpeed_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoControlSpeed_getTranslationDictValues", _wrap_PropertyIAutoControlSpeed_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoControlSpeed_getMaxValue", _wrap_PropertyIAutoControlSpeed_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoControlSpeed_getMinValue", _wrap_PropertyIAutoControlSpeed_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoControlSpeed_getStepWidth", _wrap_PropertyIAutoControlSpeed_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoControlSpeed_read", _wrap_PropertyIAutoControlSpeed_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIAutoControlSpeed_write", _wrap_PropertyIAutoControlSpeed_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIAutoControlSpeed", _wrap_delete_PropertyIAutoControlSpeed, METH_O, NULL},
	 { "PropertyIAutoControlSpeed_swigregister", PropertyIAutoControlSpeed_swigregister, METH_O, NULL},
	 { "PropertyIAutoControlSpeed_swiginit", PropertyIAutoControlSpeed_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTAutoControlSpeed", _wrap_new_pairstringTAutoControlSpeed, METH_VARARGS, NULL},
	 { "pairstringTAutoControlSpeed_first_set", _wrap_pairstringTAutoControlSpeed_first_set, METH_VARARGS, NULL},
	 { "pairstringTAutoControlSpeed_first_get", _wrap_pairstringTAutoControlSpeed_first_get, METH_O, NULL},
	 { "pairstringTAutoControlSpeed_second_set", _wrap_pairstringTAutoControlSpeed_second_set, METH_VARARGS, NULL},
	 { "pairstringTAutoControlSpeed_second_get", _wrap_pairstringTAutoControlSpeed_second_get, METH_O, NULL},
	 { "delete_pairstringTAutoControlSpeed", _wrap_delete_pairstringTAutoControlSpeed, METH_O, NULL},
	 { "pairstringTAutoControlSpeed_swigregister", pairstringTAutoControlSpeed_swigregister, METH_O, NULL},
	 { "pairstringTAutoControlSpeed_swiginit", pairstringTAutoControlSpeed_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIAutoControlMode", _wrap_new_PropertyIAutoControlMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIAutoControlMode_getTranslationDict", _wrap_PropertyIAutoControlMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIAutoControlMode_getTranslationDictString", _wrap_PropertyIAutoControlMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoControlMode_getTranslationDictValue", _wrap_PropertyIAutoControlMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoControlMode_getTranslationDictStrings", _wrap_PropertyIAutoControlMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoControlMode_getTranslationDictValues", _wrap_PropertyIAutoControlMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoControlMode_getMaxValue", _wrap_PropertyIAutoControlMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoControlMode_getMinValue", _wrap_PropertyIAutoControlMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoControlMode_getStepWidth", _wrap_PropertyIAutoControlMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoControlMode_read", _wrap_PropertyIAutoControlMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIAutoControlMode_write", _wrap_PropertyIAutoControlMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIAutoControlMode", _wrap_delete_PropertyIAutoControlMode, METH_O, NULL},
	 { "PropertyIAutoControlMode_swigregister", PropertyIAutoControlMode_swigregister, METH_O, NULL},
	 { "PropertyIAutoControlMode_swiginit", PropertyIAutoControlMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTAutoControlMode", _wrap_new_pairstringTAutoControlMode, METH_VARARGS, NULL},
	 { "pairstringTAutoControlMode_first_set", _wrap_pairstringTAutoControlMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTAutoControlMode_first_get", _wrap_pairstringTAutoControlMode_first_get, METH_O, NULL},
	 { "pairstringTAutoControlMode_second_set", _wrap_pairstringTAutoControlMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTAutoControlMode_second_get", _wrap_pairstringTAutoControlMode_second_get, METH_O, NULL},
	 { "delete_pairstringTAutoControlMode", _wrap_delete_pairstringTAutoControlMode, METH_O, NULL},
	 { "pairstringTAutoControlMode_swigregister", pairstringTAutoControlMode_swigregister, METH_O, NULL},
	 { "pairstringTAutoControlMode_swiginit", pairstringTAutoControlMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIAutoExposureControl", _wrap_new_PropertyIAutoExposureControl, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIAutoExposureControl_getTranslationDict", _wrap_PropertyIAutoExposureControl_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIAutoExposureControl_getTranslationDictString", _wrap_PropertyIAutoExposureControl_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoExposureControl_getTranslationDictValue", _wrap_PropertyIAutoExposureControl_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoExposureControl_getTranslationDictStrings", _wrap_PropertyIAutoExposureControl_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoExposureControl_getTranslationDictValues", _wrap_PropertyIAutoExposureControl_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoExposureControl_getMaxValue", _wrap_PropertyIAutoExposureControl_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoExposureControl_getMinValue", _wrap_PropertyIAutoExposureControl_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoExposureControl_getStepWidth", _wrap_PropertyIAutoExposureControl_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoExposureControl_read", _wrap_PropertyIAutoExposureControl_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIAutoExposureControl_write", _wrap_PropertyIAutoExposureControl_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIAutoExposureControl", _wrap_delete_PropertyIAutoExposureControl, METH_O, NULL},
	 { "PropertyIAutoExposureControl_swigregister", PropertyIAutoExposureControl_swigregister, METH_O, NULL},
	 { "PropertyIAutoExposureControl_swiginit", PropertyIAutoExposureControl_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTAutoExposureControl", _wrap_new_pairstringTAutoExposureControl, METH_VARARGS, NULL},
	 { "pairstringTAutoExposureControl_first_set", _wrap_pairstringTAutoExposureControl_first_set, METH_VARARGS, NULL},
	 { "pairstringTAutoExposureControl_first_get", _wrap_pairstringTAutoExposureControl_first_get, METH_O, NULL},
	 { "pairstringTAutoExposureControl_second_set", _wrap_pairstringTAutoExposureControl_second_set, METH_VARARGS, NULL},
	 { "pairstringTAutoExposureControl_second_get", _wrap_pairstringTAutoExposureControl_second_get, METH_O, NULL},
	 { "delete_pairstringTAutoExposureControl", _wrap_delete_pairstringTAutoExposureControl, METH_O, NULL},
	 { "pairstringTAutoExposureControl_swigregister", pairstringTAutoExposureControl_swigregister, METH_O, NULL},
	 { "pairstringTAutoExposureControl_swiginit", pairstringTAutoExposureControl_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIAutoGainControl", _wrap_new_PropertyIAutoGainControl, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIAutoGainControl_getTranslationDict", _wrap_PropertyIAutoGainControl_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIAutoGainControl_getTranslationDictString", _wrap_PropertyIAutoGainControl_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoGainControl_getTranslationDictValue", _wrap_PropertyIAutoGainControl_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoGainControl_getTranslationDictStrings", _wrap_PropertyIAutoGainControl_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoGainControl_getTranslationDictValues", _wrap_PropertyIAutoGainControl_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoGainControl_getMaxValue", _wrap_PropertyIAutoGainControl_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoGainControl_getMinValue", _wrap_PropertyIAutoGainControl_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoGainControl_getStepWidth", _wrap_PropertyIAutoGainControl_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoGainControl_read", _wrap_PropertyIAutoGainControl_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIAutoGainControl_write", _wrap_PropertyIAutoGainControl_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIAutoGainControl", _wrap_delete_PropertyIAutoGainControl, METH_O, NULL},
	 { "PropertyIAutoGainControl_swigregister", PropertyIAutoGainControl_swigregister, METH_O, NULL},
	 { "PropertyIAutoGainControl_swiginit", PropertyIAutoGainControl_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTAutoGainControl", _wrap_new_pairstringTAutoGainControl, METH_VARARGS, NULL},
	 { "pairstringTAutoGainControl_first_set", _wrap_pairstringTAutoGainControl_first_set, METH_VARARGS, NULL},
	 { "pairstringTAutoGainControl_first_get", _wrap_pairstringTAutoGainControl_first_get, METH_O, NULL},
	 { "pairstringTAutoGainControl_second_set", _wrap_pairstringTAutoGainControl_second_set, METH_VARARGS, NULL},
	 { "pairstringTAutoGainControl_second_get", _wrap_pairstringTAutoGainControl_second_get, METH_O, NULL},
	 { "delete_pairstringTAutoGainControl", _wrap_delete_pairstringTAutoGainControl, METH_O, NULL},
	 { "pairstringTAutoGainControl_swigregister", pairstringTAutoGainControl_swigregister, METH_O, NULL},
	 { "pairstringTAutoGainControl_swiginit", pairstringTAutoGainControl_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIAutoOffsetCalibration", _wrap_new_PropertyIAutoOffsetCalibration, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIAutoOffsetCalibration_getTranslationDict", _wrap_PropertyIAutoOffsetCalibration_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIAutoOffsetCalibration_getTranslationDictString", _wrap_PropertyIAutoOffsetCalibration_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoOffsetCalibration_getTranslationDictValue", _wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIAutoOffsetCalibration_getTranslationDictStrings", _wrap_PropertyIAutoOffsetCalibration_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoOffsetCalibration_getTranslationDictValues", _wrap_PropertyIAutoOffsetCalibration_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIAutoOffsetCalibration_getMaxValue", _wrap_PropertyIAutoOffsetCalibration_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoOffsetCalibration_getMinValue", _wrap_PropertyIAutoOffsetCalibration_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoOffsetCalibration_getStepWidth", _wrap_PropertyIAutoOffsetCalibration_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIAutoOffsetCalibration_read", _wrap_PropertyIAutoOffsetCalibration_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIAutoOffsetCalibration_write", _wrap_PropertyIAutoOffsetCalibration_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIAutoOffsetCalibration", _wrap_delete_PropertyIAutoOffsetCalibration, METH_O, NULL},
	 { "PropertyIAutoOffsetCalibration_swigregister", PropertyIAutoOffsetCalibration_swigregister, METH_O, NULL},
	 { "PropertyIAutoOffsetCalibration_swiginit", PropertyIAutoOffsetCalibration_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTAutoOffsetCalibration", _wrap_new_pairstringTAutoOffsetCalibration, METH_VARARGS, NULL},
	 { "pairstringTAutoOffsetCalibration_first_set", _wrap_pairstringTAutoOffsetCalibration_first_set, METH_VARARGS, NULL},
	 { "pairstringTAutoOffsetCalibration_first_get", _wrap_pairstringTAutoOffsetCalibration_first_get, METH_O, NULL},
	 { "pairstringTAutoOffsetCalibration_second_set", _wrap_pairstringTAutoOffsetCalibration_second_set, METH_VARARGS, NULL},
	 { "pairstringTAutoOffsetCalibration_second_get", _wrap_pairstringTAutoOffsetCalibration_second_get, METH_O, NULL},
	 { "delete_pairstringTAutoOffsetCalibration", _wrap_delete_pairstringTAutoOffsetCalibration, METH_O, NULL},
	 { "pairstringTAutoOffsetCalibration_swigregister", pairstringTAutoOffsetCalibration_swigregister, METH_O, NULL},
	 { "pairstringTAutoOffsetCalibration_swiginit", pairstringTAutoOffsetCalibration_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBayerConversionMode", _wrap_new_PropertyIBayerConversionMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBayerConversionMode_getTranslationDict", _wrap_PropertyIBayerConversionMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBayerConversionMode_getTranslationDictString", _wrap_PropertyIBayerConversionMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBayerConversionMode_getTranslationDictValue", _wrap_PropertyIBayerConversionMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBayerConversionMode_getTranslationDictStrings", _wrap_PropertyIBayerConversionMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBayerConversionMode_getTranslationDictValues", _wrap_PropertyIBayerConversionMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBayerConversionMode_getMaxValue", _wrap_PropertyIBayerConversionMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBayerConversionMode_getMinValue", _wrap_PropertyIBayerConversionMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBayerConversionMode_getStepWidth", _wrap_PropertyIBayerConversionMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBayerConversionMode_read", _wrap_PropertyIBayerConversionMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBayerConversionMode_write", _wrap_PropertyIBayerConversionMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBayerConversionMode", _wrap_delete_PropertyIBayerConversionMode, METH_O, NULL},
	 { "PropertyIBayerConversionMode_swigregister", PropertyIBayerConversionMode_swigregister, METH_O, NULL},
	 { "PropertyIBayerConversionMode_swiginit", PropertyIBayerConversionMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBayerConversionMode", _wrap_new_pairstringTBayerConversionMode, METH_VARARGS, NULL},
	 { "pairstringTBayerConversionMode_first_set", _wrap_pairstringTBayerConversionMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTBayerConversionMode_first_get", _wrap_pairstringTBayerConversionMode_first_get, METH_O, NULL},
	 { "pairstringTBayerConversionMode_second_set", _wrap_pairstringTBayerConversionMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTBayerConversionMode_second_get", _wrap_pairstringTBayerConversionMode_second_get, METH_O, NULL},
	 { "delete_pairstringTBayerConversionMode", _wrap_delete_pairstringTBayerConversionMode, METH_O, NULL},
	 { "pairstringTBayerConversionMode_swigregister", pairstringTBayerConversionMode_swigregister, METH_O, NULL},
	 { "pairstringTBayerConversionMode_swiginit", pairstringTBayerConversionMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBayerMosaicParity", _wrap_new_PropertyIBayerMosaicParity, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBayerMosaicParity_getTranslationDict", _wrap_PropertyIBayerMosaicParity_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBayerMosaicParity_getTranslationDictString", _wrap_PropertyIBayerMosaicParity_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBayerMosaicParity_getTranslationDictValue", _wrap_PropertyIBayerMosaicParity_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBayerMosaicParity_getTranslationDictStrings", _wrap_PropertyIBayerMosaicParity_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBayerMosaicParity_getTranslationDictValues", _wrap_PropertyIBayerMosaicParity_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBayerMosaicParity_getMaxValue", _wrap_PropertyIBayerMosaicParity_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBayerMosaicParity_getMinValue", _wrap_PropertyIBayerMosaicParity_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBayerMosaicParity_getStepWidth", _wrap_PropertyIBayerMosaicParity_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBayerMosaicParity_read", _wrap_PropertyIBayerMosaicParity_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBayerMosaicParity_write", _wrap_PropertyIBayerMosaicParity_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBayerMosaicParity", _wrap_delete_PropertyIBayerMosaicParity, METH_O, NULL},
	 { "PropertyIBayerMosaicParity_swigregister", PropertyIBayerMosaicParity_swigregister, METH_O, NULL},
	 { "PropertyIBayerMosaicParity_swiginit", PropertyIBayerMosaicParity_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBayerMosaicParity", _wrap_new_pairstringTBayerMosaicParity, METH_VARARGS, NULL},
	 { "pairstringTBayerMosaicParity_first_set", _wrap_pairstringTBayerMosaicParity_first_set, METH_VARARGS, NULL},
	 { "pairstringTBayerMosaicParity_first_get", _wrap_pairstringTBayerMosaicParity_first_get, METH_O, NULL},
	 { "pairstringTBayerMosaicParity_second_set", _wrap_pairstringTBayerMosaicParity_second_set, METH_VARARGS, NULL},
	 { "pairstringTBayerMosaicParity_second_get", _wrap_pairstringTBayerMosaicParity_second_get, METH_O, NULL},
	 { "delete_pairstringTBayerMosaicParity", _wrap_delete_pairstringTBayerMosaicParity, METH_O, NULL},
	 { "pairstringTBayerMosaicParity_swigregister", pairstringTBayerMosaicParity_swigregister, METH_O, NULL},
	 { "pairstringTBayerMosaicParity_swiginit", pairstringTBayerMosaicParity_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBayerWhiteBalanceResult", _wrap_new_PropertyIBayerWhiteBalanceResult, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_getTranslationDict", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_getTranslationDictString", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_getTranslationDictValue", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_getTranslationDictStrings", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_getTranslationDictValues", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_getMaxValue", _wrap_PropertyIBayerWhiteBalanceResult_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_getMinValue", _wrap_PropertyIBayerWhiteBalanceResult_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_getStepWidth", _wrap_PropertyIBayerWhiteBalanceResult_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_read", _wrap_PropertyIBayerWhiteBalanceResult_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBayerWhiteBalanceResult_write", _wrap_PropertyIBayerWhiteBalanceResult_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBayerWhiteBalanceResult", _wrap_delete_PropertyIBayerWhiteBalanceResult, METH_O, NULL},
	 { "PropertyIBayerWhiteBalanceResult_swigregister", PropertyIBayerWhiteBalanceResult_swigregister, METH_O, NULL},
	 { "PropertyIBayerWhiteBalanceResult_swiginit", PropertyIBayerWhiteBalanceResult_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBayerWhiteBalanceResult", _wrap_new_pairstringTBayerWhiteBalanceResult, METH_VARARGS, NULL},
	 { "pairstringTBayerWhiteBalanceResult_first_set", _wrap_pairstringTBayerWhiteBalanceResult_first_set, METH_VARARGS, NULL},
	 { "pairstringTBayerWhiteBalanceResult_first_get", _wrap_pairstringTBayerWhiteBalanceResult_first_get, METH_O, NULL},
	 { "pairstringTBayerWhiteBalanceResult_second_set", _wrap_pairstringTBayerWhiteBalanceResult_second_set, METH_VARARGS, NULL},
	 { "pairstringTBayerWhiteBalanceResult_second_get", _wrap_pairstringTBayerWhiteBalanceResult_second_get, METH_O, NULL},
	 { "delete_pairstringTBayerWhiteBalanceResult", _wrap_delete_pairstringTBayerWhiteBalanceResult, METH_O, NULL},
	 { "pairstringTBayerWhiteBalanceResult_swigregister", pairstringTBayerWhiteBalanceResult_swigregister, METH_O, NULL},
	 { "pairstringTBayerWhiteBalanceResult_swiginit", pairstringTBayerWhiteBalanceResult_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBlueFOXDigitalInputThreshold", _wrap_new_PropertyIBlueFOXDigitalInputThreshold, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_getTranslationDict", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValues", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_getMaxValue", _wrap_PropertyIBlueFOXDigitalInputThreshold_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_getMinValue", _wrap_PropertyIBlueFOXDigitalInputThreshold_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_getStepWidth", _wrap_PropertyIBlueFOXDigitalInputThreshold_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_read", _wrap_PropertyIBlueFOXDigitalInputThreshold_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBlueFOXDigitalInputThreshold_write", _wrap_PropertyIBlueFOXDigitalInputThreshold_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBlueFOXDigitalInputThreshold", _wrap_delete_PropertyIBlueFOXDigitalInputThreshold, METH_O, NULL},
	 { "PropertyIBlueFOXDigitalInputThreshold_swigregister", PropertyIBlueFOXDigitalInputThreshold_swigregister, METH_O, NULL},
	 { "PropertyIBlueFOXDigitalInputThreshold_swiginit", PropertyIBlueFOXDigitalInputThreshold_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBlueFOXDigitalInputThreshold", _wrap_new_pairstringTBlueFOXDigitalInputThreshold, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXDigitalInputThreshold_first_set", _wrap_pairstringTBlueFOXDigitalInputThreshold_first_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXDigitalInputThreshold_first_get", _wrap_pairstringTBlueFOXDigitalInputThreshold_first_get, METH_O, NULL},
	 { "pairstringTBlueFOXDigitalInputThreshold_second_set", _wrap_pairstringTBlueFOXDigitalInputThreshold_second_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXDigitalInputThreshold_second_get", _wrap_pairstringTBlueFOXDigitalInputThreshold_second_get, METH_O, NULL},
	 { "delete_pairstringTBlueFOXDigitalInputThreshold", _wrap_delete_pairstringTBlueFOXDigitalInputThreshold, METH_O, NULL},
	 { "pairstringTBlueFOXDigitalInputThreshold_swigregister", pairstringTBlueFOXDigitalInputThreshold_swigregister, METH_O, NULL},
	 { "pairstringTBlueFOXDigitalInputThreshold_swiginit", pairstringTBlueFOXDigitalInputThreshold_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBlueFOXFooterMode", _wrap_new_PropertyIBlueFOXFooterMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBlueFOXFooterMode_getTranslationDict", _wrap_PropertyIBlueFOXFooterMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBlueFOXFooterMode_getTranslationDictString", _wrap_PropertyIBlueFOXFooterMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXFooterMode_getTranslationDictValue", _wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXFooterMode_getTranslationDictStrings", _wrap_PropertyIBlueFOXFooterMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXFooterMode_getTranslationDictValues", _wrap_PropertyIBlueFOXFooterMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXFooterMode_getMaxValue", _wrap_PropertyIBlueFOXFooterMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXFooterMode_getMinValue", _wrap_PropertyIBlueFOXFooterMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXFooterMode_getStepWidth", _wrap_PropertyIBlueFOXFooterMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXFooterMode_read", _wrap_PropertyIBlueFOXFooterMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBlueFOXFooterMode_write", _wrap_PropertyIBlueFOXFooterMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBlueFOXFooterMode", _wrap_delete_PropertyIBlueFOXFooterMode, METH_O, NULL},
	 { "PropertyIBlueFOXFooterMode_swigregister", PropertyIBlueFOXFooterMode_swigregister, METH_O, NULL},
	 { "PropertyIBlueFOXFooterMode_swiginit", PropertyIBlueFOXFooterMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBlueFOXFooterMode", _wrap_new_pairstringTBlueFOXFooterMode, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXFooterMode_first_set", _wrap_pairstringTBlueFOXFooterMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXFooterMode_first_get", _wrap_pairstringTBlueFOXFooterMode_first_get, METH_O, NULL},
	 { "pairstringTBlueFOXFooterMode_second_set", _wrap_pairstringTBlueFOXFooterMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXFooterMode_second_get", _wrap_pairstringTBlueFOXFooterMode_second_get, METH_O, NULL},
	 { "delete_pairstringTBlueFOXFooterMode", _wrap_delete_pairstringTBlueFOXFooterMode, METH_O, NULL},
	 { "pairstringTBlueFOXFooterMode_swigregister", pairstringTBlueFOXFooterMode_swigregister, METH_O, NULL},
	 { "pairstringTBlueFOXFooterMode_swiginit", pairstringTBlueFOXFooterMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBlueFOXInfoSensorCapabilities", _wrap_new_PropertyIBlueFOXInfoSensorCapabilities, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValues", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_getMaxValue", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_getMinValue", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_getStepWidth", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_read", _wrap_PropertyIBlueFOXInfoSensorCapabilities_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBlueFOXInfoSensorCapabilities_write", _wrap_PropertyIBlueFOXInfoSensorCapabilities_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBlueFOXInfoSensorCapabilities", _wrap_delete_PropertyIBlueFOXInfoSensorCapabilities, METH_O, NULL},
	 { "PropertyIBlueFOXInfoSensorCapabilities_swigregister", PropertyIBlueFOXInfoSensorCapabilities_swigregister, METH_O, NULL},
	 { "PropertyIBlueFOXInfoSensorCapabilities_swiginit", PropertyIBlueFOXInfoSensorCapabilities_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBlueFOXInfoSensorCapabilities", _wrap_new_pairstringTBlueFOXInfoSensorCapabilities, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXInfoSensorCapabilities_first_set", _wrap_pairstringTBlueFOXInfoSensorCapabilities_first_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXInfoSensorCapabilities_first_get", _wrap_pairstringTBlueFOXInfoSensorCapabilities_first_get, METH_O, NULL},
	 { "pairstringTBlueFOXInfoSensorCapabilities_second_set", _wrap_pairstringTBlueFOXInfoSensorCapabilities_second_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXInfoSensorCapabilities_second_get", _wrap_pairstringTBlueFOXInfoSensorCapabilities_second_get, METH_O, NULL},
	 { "delete_pairstringTBlueFOXInfoSensorCapabilities", _wrap_delete_pairstringTBlueFOXInfoSensorCapabilities, METH_O, NULL},
	 { "pairstringTBlueFOXInfoSensorCapabilities_swigregister", pairstringTBlueFOXInfoSensorCapabilities_swigregister, METH_O, NULL},
	 { "pairstringTBlueFOXInfoSensorCapabilities_swiginit", pairstringTBlueFOXInfoSensorCapabilities_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBlueFOXOffsetAutoBlackSpeed", _wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValues", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_getMaxValue", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_getMinValue", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_getStepWidth", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_read", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_write", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBlueFOXOffsetAutoBlackSpeed", _wrap_delete_PropertyIBlueFOXOffsetAutoBlackSpeed, METH_O, NULL},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_swigregister", PropertyIBlueFOXOffsetAutoBlackSpeed_swigregister, METH_O, NULL},
	 { "PropertyIBlueFOXOffsetAutoBlackSpeed_swiginit", PropertyIBlueFOXOffsetAutoBlackSpeed_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBlueFOXOffsetAutoBlackSpeed", _wrap_new_pairstringTBlueFOXOffsetAutoBlackSpeed, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXOffsetAutoBlackSpeed_first_set", _wrap_pairstringTBlueFOXOffsetAutoBlackSpeed_first_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXOffsetAutoBlackSpeed_first_get", _wrap_pairstringTBlueFOXOffsetAutoBlackSpeed_first_get, METH_O, NULL},
	 { "pairstringTBlueFOXOffsetAutoBlackSpeed_second_set", _wrap_pairstringTBlueFOXOffsetAutoBlackSpeed_second_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXOffsetAutoBlackSpeed_second_get", _wrap_pairstringTBlueFOXOffsetAutoBlackSpeed_second_get, METH_O, NULL},
	 { "delete_pairstringTBlueFOXOffsetAutoBlackSpeed", _wrap_delete_pairstringTBlueFOXOffsetAutoBlackSpeed, METH_O, NULL},
	 { "pairstringTBlueFOXOffsetAutoBlackSpeed_swigregister", pairstringTBlueFOXOffsetAutoBlackSpeed_swigregister, METH_O, NULL},
	 { "pairstringTBlueFOXOffsetAutoBlackSpeed_swiginit", pairstringTBlueFOXOffsetAutoBlackSpeed_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBlueFOXSensorTiming", _wrap_new_PropertyIBlueFOXSensorTiming, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_getTranslationDict", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_getTranslationDictString", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_getTranslationDictValue", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_getTranslationDictStrings", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_getTranslationDictValues", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_getMaxValue", _wrap_PropertyIBlueFOXSensorTiming_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_getMinValue", _wrap_PropertyIBlueFOXSensorTiming_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_getStepWidth", _wrap_PropertyIBlueFOXSensorTiming_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_read", _wrap_PropertyIBlueFOXSensorTiming_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBlueFOXSensorTiming_write", _wrap_PropertyIBlueFOXSensorTiming_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBlueFOXSensorTiming", _wrap_delete_PropertyIBlueFOXSensorTiming, METH_O, NULL},
	 { "PropertyIBlueFOXSensorTiming_swigregister", PropertyIBlueFOXSensorTiming_swigregister, METH_O, NULL},
	 { "PropertyIBlueFOXSensorTiming_swiginit", PropertyIBlueFOXSensorTiming_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBlueFOXSensorTiming", _wrap_new_pairstringTBlueFOXSensorTiming, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXSensorTiming_first_set", _wrap_pairstringTBlueFOXSensorTiming_first_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXSensorTiming_first_get", _wrap_pairstringTBlueFOXSensorTiming_first_get, METH_O, NULL},
	 { "pairstringTBlueFOXSensorTiming_second_set", _wrap_pairstringTBlueFOXSensorTiming_second_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXSensorTiming_second_get", _wrap_pairstringTBlueFOXSensorTiming_second_get, METH_O, NULL},
	 { "delete_pairstringTBlueFOXSensorTiming", _wrap_delete_pairstringTBlueFOXSensorTiming, METH_O, NULL},
	 { "pairstringTBlueFOXSensorTiming_swigregister", pairstringTBlueFOXSensorTiming_swigregister, METH_O, NULL},
	 { "pairstringTBlueFOXSensorTiming_swiginit", pairstringTBlueFOXSensorTiming_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBlueFOXTransferSize", _wrap_new_PropertyIBlueFOXTransferSize, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBlueFOXTransferSize_getTranslationDict", _wrap_PropertyIBlueFOXTransferSize_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBlueFOXTransferSize_getTranslationDictString", _wrap_PropertyIBlueFOXTransferSize_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXTransferSize_getTranslationDictValue", _wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBlueFOXTransferSize_getTranslationDictStrings", _wrap_PropertyIBlueFOXTransferSize_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXTransferSize_getTranslationDictValues", _wrap_PropertyIBlueFOXTransferSize_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBlueFOXTransferSize_getMaxValue", _wrap_PropertyIBlueFOXTransferSize_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXTransferSize_getMinValue", _wrap_PropertyIBlueFOXTransferSize_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXTransferSize_getStepWidth", _wrap_PropertyIBlueFOXTransferSize_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBlueFOXTransferSize_read", _wrap_PropertyIBlueFOXTransferSize_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBlueFOXTransferSize_write", _wrap_PropertyIBlueFOXTransferSize_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBlueFOXTransferSize", _wrap_delete_PropertyIBlueFOXTransferSize, METH_O, NULL},
	 { "PropertyIBlueFOXTransferSize_swigregister", PropertyIBlueFOXTransferSize_swigregister, METH_O, NULL},
	 { "PropertyIBlueFOXTransferSize_swiginit", PropertyIBlueFOXTransferSize_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBlueFOXTransferSize", _wrap_new_pairstringTBlueFOXTransferSize, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXTransferSize_first_set", _wrap_pairstringTBlueFOXTransferSize_first_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXTransferSize_first_get", _wrap_pairstringTBlueFOXTransferSize_first_get, METH_O, NULL},
	 { "pairstringTBlueFOXTransferSize_second_set", _wrap_pairstringTBlueFOXTransferSize_second_set, METH_VARARGS, NULL},
	 { "pairstringTBlueFOXTransferSize_second_get", _wrap_pairstringTBlueFOXTransferSize_second_get, METH_O, NULL},
	 { "delete_pairstringTBlueFOXTransferSize", _wrap_delete_pairstringTBlueFOXTransferSize, METH_O, NULL},
	 { "pairstringTBlueFOXTransferSize_swigregister", pairstringTBlueFOXTransferSize_swigregister, METH_O, NULL},
	 { "pairstringTBlueFOXTransferSize_swiginit", pairstringTBlueFOXTransferSize_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIBoolean", _wrap_new_PropertyIBoolean, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIBoolean_getTranslationDict", _wrap_PropertyIBoolean_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBoolean >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBoolean > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIBoolean_getTranslationDictString", _wrap_PropertyIBoolean_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBoolean_getTranslationDictValue", _wrap_PropertyIBoolean_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIBoolean_getTranslationDictStrings", _wrap_PropertyIBoolean_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBoolean_getTranslationDictValues", _wrap_PropertyIBoolean_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIBoolean_getMaxValue", _wrap_PropertyIBoolean_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBoolean_getMinValue", _wrap_PropertyIBoolean_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBoolean_getStepWidth", _wrap_PropertyIBoolean_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIBoolean_read", _wrap_PropertyIBoolean_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIBoolean_write", _wrap_PropertyIBoolean_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIBoolean", _wrap_delete_PropertyIBoolean, METH_O, NULL},
	 { "PropertyIBoolean_swigregister", PropertyIBoolean_swigregister, METH_O, NULL},
	 { "PropertyIBoolean_swiginit", PropertyIBoolean_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBoolean", _wrap_new_pairstringTBoolean, METH_VARARGS, NULL},
	 { "pairstringTBoolean_first_set", _wrap_pairstringTBoolean_first_set, METH_VARARGS, NULL},
	 { "pairstringTBoolean_first_get", _wrap_pairstringTBoolean_first_get, METH_O, NULL},
	 { "pairstringTBoolean_second_set", _wrap_pairstringTBoolean_second_set, METH_VARARGS, NULL},
	 { "pairstringTBoolean_second_get", _wrap_pairstringTBoolean_second_get, METH_O, NULL},
	 { "delete_pairstringTBoolean", _wrap_delete_pairstringTBoolean, METH_O, NULL},
	 { "pairstringTBoolean_swigregister", pairstringTBoolean_swigregister, METH_O, NULL},
	 { "pairstringTBoolean_swiginit", pairstringTBoolean_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraAoiMode", _wrap_new_PropertyICameraAoiMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraAoiMode_getTranslationDict", _wrap_PropertyICameraAoiMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraAoiMode_getTranslationDictString", _wrap_PropertyICameraAoiMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraAoiMode_getTranslationDictValue", _wrap_PropertyICameraAoiMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraAoiMode_getTranslationDictStrings", _wrap_PropertyICameraAoiMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraAoiMode_getTranslationDictValues", _wrap_PropertyICameraAoiMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraAoiMode_getMaxValue", _wrap_PropertyICameraAoiMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraAoiMode_getMinValue", _wrap_PropertyICameraAoiMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraAoiMode_getStepWidth", _wrap_PropertyICameraAoiMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraAoiMode_read", _wrap_PropertyICameraAoiMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraAoiMode_write", _wrap_PropertyICameraAoiMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraAoiMode", _wrap_delete_PropertyICameraAoiMode, METH_O, NULL},
	 { "PropertyICameraAoiMode_swigregister", PropertyICameraAoiMode_swigregister, METH_O, NULL},
	 { "PropertyICameraAoiMode_swiginit", PropertyICameraAoiMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraAoiMode", _wrap_new_pairstringTCameraAoiMode, METH_VARARGS, NULL},
	 { "pairstringTCameraAoiMode_first_set", _wrap_pairstringTCameraAoiMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraAoiMode_first_get", _wrap_pairstringTCameraAoiMode_first_get, METH_O, NULL},
	 { "pairstringTCameraAoiMode_second_set", _wrap_pairstringTCameraAoiMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraAoiMode_second_get", _wrap_pairstringTCameraAoiMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraAoiMode", _wrap_delete_pairstringTCameraAoiMode, METH_O, NULL},
	 { "pairstringTCameraAoiMode_swigregister", pairstringTCameraAoiMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraAoiMode_swiginit", pairstringTCameraAoiMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraBinningMode", _wrap_new_PropertyICameraBinningMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraBinningMode_getTranslationDict", _wrap_PropertyICameraBinningMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraBinningMode_getTranslationDictString", _wrap_PropertyICameraBinningMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraBinningMode_getTranslationDictValue", _wrap_PropertyICameraBinningMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraBinningMode_getTranslationDictStrings", _wrap_PropertyICameraBinningMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraBinningMode_getTranslationDictValues", _wrap_PropertyICameraBinningMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraBinningMode_getMaxValue", _wrap_PropertyICameraBinningMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraBinningMode_getMinValue", _wrap_PropertyICameraBinningMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraBinningMode_getStepWidth", _wrap_PropertyICameraBinningMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraBinningMode_read", _wrap_PropertyICameraBinningMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraBinningMode_write", _wrap_PropertyICameraBinningMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraBinningMode", _wrap_delete_PropertyICameraBinningMode, METH_O, NULL},
	 { "PropertyICameraBinningMode_swigregister", PropertyICameraBinningMode_swigregister, METH_O, NULL},
	 { "PropertyICameraBinningMode_swiginit", PropertyICameraBinningMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraBinningMode", _wrap_new_pairstringTCameraBinningMode, METH_VARARGS, NULL},
	 { "pairstringTCameraBinningMode_first_set", _wrap_pairstringTCameraBinningMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraBinningMode_first_get", _wrap_pairstringTCameraBinningMode_first_get, METH_O, NULL},
	 { "pairstringTCameraBinningMode_second_set", _wrap_pairstringTCameraBinningMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraBinningMode_second_get", _wrap_pairstringTCameraBinningMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraBinningMode", _wrap_delete_pairstringTCameraBinningMode, METH_O, NULL},
	 { "pairstringTCameraBinningMode_swigregister", pairstringTCameraBinningMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraBinningMode_swiginit", pairstringTCameraBinningMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraDataFormat", _wrap_new_PropertyICameraDataFormat, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraDataFormat_getTranslationDict", _wrap_PropertyICameraDataFormat_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraDataFormat_getTranslationDictString", _wrap_PropertyICameraDataFormat_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraDataFormat_getTranslationDictValue", _wrap_PropertyICameraDataFormat_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraDataFormat_getTranslationDictStrings", _wrap_PropertyICameraDataFormat_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraDataFormat_getTranslationDictValues", _wrap_PropertyICameraDataFormat_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraDataFormat_getMaxValue", _wrap_PropertyICameraDataFormat_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraDataFormat_getMinValue", _wrap_PropertyICameraDataFormat_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraDataFormat_getStepWidth", _wrap_PropertyICameraDataFormat_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraDataFormat_read", _wrap_PropertyICameraDataFormat_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraDataFormat_write", _wrap_PropertyICameraDataFormat_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraDataFormat", _wrap_delete_PropertyICameraDataFormat, METH_O, NULL},
	 { "PropertyICameraDataFormat_swigregister", PropertyICameraDataFormat_swigregister, METH_O, NULL},
	 { "PropertyICameraDataFormat_swiginit", PropertyICameraDataFormat_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraDataFormat", _wrap_new_pairstringTCameraDataFormat, METH_VARARGS, NULL},
	 { "pairstringTCameraDataFormat_first_set", _wrap_pairstringTCameraDataFormat_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraDataFormat_first_get", _wrap_pairstringTCameraDataFormat_first_get, METH_O, NULL},
	 { "pairstringTCameraDataFormat_second_set", _wrap_pairstringTCameraDataFormat_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraDataFormat_second_get", _wrap_pairstringTCameraDataFormat_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraDataFormat", _wrap_delete_pairstringTCameraDataFormat, METH_O, NULL},
	 { "pairstringTCameraDataFormat_swigregister", pairstringTCameraDataFormat_swigregister, METH_O, NULL},
	 { "pairstringTCameraDataFormat_swiginit", pairstringTCameraDataFormat_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraExposeMode", _wrap_new_PropertyICameraExposeMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraExposeMode_getTranslationDict", _wrap_PropertyICameraExposeMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraExposeMode_getTranslationDictString", _wrap_PropertyICameraExposeMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraExposeMode_getTranslationDictValue", _wrap_PropertyICameraExposeMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraExposeMode_getTranslationDictStrings", _wrap_PropertyICameraExposeMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraExposeMode_getTranslationDictValues", _wrap_PropertyICameraExposeMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraExposeMode_getMaxValue", _wrap_PropertyICameraExposeMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraExposeMode_getMinValue", _wrap_PropertyICameraExposeMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraExposeMode_getStepWidth", _wrap_PropertyICameraExposeMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraExposeMode_read", _wrap_PropertyICameraExposeMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraExposeMode_write", _wrap_PropertyICameraExposeMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraExposeMode", _wrap_delete_PropertyICameraExposeMode, METH_O, NULL},
	 { "PropertyICameraExposeMode_swigregister", PropertyICameraExposeMode_swigregister, METH_O, NULL},
	 { "PropertyICameraExposeMode_swiginit", PropertyICameraExposeMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraExposeMode", _wrap_new_pairstringTCameraExposeMode, METH_VARARGS, NULL},
	 { "pairstringTCameraExposeMode_first_set", _wrap_pairstringTCameraExposeMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraExposeMode_first_get", _wrap_pairstringTCameraExposeMode_first_get, METH_O, NULL},
	 { "pairstringTCameraExposeMode_second_set", _wrap_pairstringTCameraExposeMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraExposeMode_second_get", _wrap_pairstringTCameraExposeMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraExposeMode", _wrap_delete_pairstringTCameraExposeMode, METH_O, NULL},
	 { "pairstringTCameraExposeMode_swigregister", pairstringTCameraExposeMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraExposeMode_swiginit", pairstringTCameraExposeMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraExternalSyncEdge", _wrap_new_PropertyICameraExternalSyncEdge, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraExternalSyncEdge_getTranslationDict", _wrap_PropertyICameraExternalSyncEdge_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraExternalSyncEdge_getTranslationDictString", _wrap_PropertyICameraExternalSyncEdge_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraExternalSyncEdge_getTranslationDictValue", _wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraExternalSyncEdge_getTranslationDictStrings", _wrap_PropertyICameraExternalSyncEdge_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraExternalSyncEdge_getTranslationDictValues", _wrap_PropertyICameraExternalSyncEdge_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraExternalSyncEdge_getMaxValue", _wrap_PropertyICameraExternalSyncEdge_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraExternalSyncEdge_getMinValue", _wrap_PropertyICameraExternalSyncEdge_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraExternalSyncEdge_getStepWidth", _wrap_PropertyICameraExternalSyncEdge_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraExternalSyncEdge_read", _wrap_PropertyICameraExternalSyncEdge_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraExternalSyncEdge_write", _wrap_PropertyICameraExternalSyncEdge_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraExternalSyncEdge", _wrap_delete_PropertyICameraExternalSyncEdge, METH_O, NULL},
	 { "PropertyICameraExternalSyncEdge_swigregister", PropertyICameraExternalSyncEdge_swigregister, METH_O, NULL},
	 { "PropertyICameraExternalSyncEdge_swiginit", PropertyICameraExternalSyncEdge_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraExternalSyncEdge", _wrap_new_pairstringTCameraExternalSyncEdge, METH_VARARGS, NULL},
	 { "pairstringTCameraExternalSyncEdge_first_set", _wrap_pairstringTCameraExternalSyncEdge_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraExternalSyncEdge_first_get", _wrap_pairstringTCameraExternalSyncEdge_first_get, METH_O, NULL},
	 { "pairstringTCameraExternalSyncEdge_second_set", _wrap_pairstringTCameraExternalSyncEdge_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraExternalSyncEdge_second_get", _wrap_pairstringTCameraExternalSyncEdge_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraExternalSyncEdge", _wrap_delete_pairstringTCameraExternalSyncEdge, METH_O, NULL},
	 { "pairstringTCameraExternalSyncEdge_swigregister", pairstringTCameraExternalSyncEdge_swigregister, METH_O, NULL},
	 { "pairstringTCameraExternalSyncEdge_swiginit", pairstringTCameraExternalSyncEdge_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraExternalSyncOutput", _wrap_new_PropertyICameraExternalSyncOutput, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraExternalSyncOutput_getTranslationDict", _wrap_PropertyICameraExternalSyncOutput_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraExternalSyncOutput_getTranslationDictString", _wrap_PropertyICameraExternalSyncOutput_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraExternalSyncOutput_getTranslationDictValue", _wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraExternalSyncOutput_getTranslationDictStrings", _wrap_PropertyICameraExternalSyncOutput_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraExternalSyncOutput_getTranslationDictValues", _wrap_PropertyICameraExternalSyncOutput_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraExternalSyncOutput_getMaxValue", _wrap_PropertyICameraExternalSyncOutput_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraExternalSyncOutput_getMinValue", _wrap_PropertyICameraExternalSyncOutput_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraExternalSyncOutput_getStepWidth", _wrap_PropertyICameraExternalSyncOutput_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraExternalSyncOutput_read", _wrap_PropertyICameraExternalSyncOutput_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraExternalSyncOutput_write", _wrap_PropertyICameraExternalSyncOutput_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraExternalSyncOutput", _wrap_delete_PropertyICameraExternalSyncOutput, METH_O, NULL},
	 { "PropertyICameraExternalSyncOutput_swigregister", PropertyICameraExternalSyncOutput_swigregister, METH_O, NULL},
	 { "PropertyICameraExternalSyncOutput_swiginit", PropertyICameraExternalSyncOutput_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraExternalSyncOutput", _wrap_new_pairstringTCameraExternalSyncOutput, METH_VARARGS, NULL},
	 { "pairstringTCameraExternalSyncOutput_first_set", _wrap_pairstringTCameraExternalSyncOutput_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraExternalSyncOutput_first_get", _wrap_pairstringTCameraExternalSyncOutput_first_get, METH_O, NULL},
	 { "pairstringTCameraExternalSyncOutput_second_set", _wrap_pairstringTCameraExternalSyncOutput_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraExternalSyncOutput_second_get", _wrap_pairstringTCameraExternalSyncOutput_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraExternalSyncOutput", _wrap_delete_pairstringTCameraExternalSyncOutput, METH_O, NULL},
	 { "pairstringTCameraExternalSyncOutput_swigregister", pairstringTCameraExternalSyncOutput_swigregister, METH_O, NULL},
	 { "pairstringTCameraExternalSyncOutput_swiginit", pairstringTCameraExternalSyncOutput_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraFlashMode", _wrap_new_PropertyICameraFlashMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraFlashMode_getTranslationDict", _wrap_PropertyICameraFlashMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraFlashMode_getTranslationDictString", _wrap_PropertyICameraFlashMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraFlashMode_getTranslationDictValue", _wrap_PropertyICameraFlashMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraFlashMode_getTranslationDictStrings", _wrap_PropertyICameraFlashMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraFlashMode_getTranslationDictValues", _wrap_PropertyICameraFlashMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraFlashMode_getMaxValue", _wrap_PropertyICameraFlashMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraFlashMode_getMinValue", _wrap_PropertyICameraFlashMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraFlashMode_getStepWidth", _wrap_PropertyICameraFlashMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraFlashMode_read", _wrap_PropertyICameraFlashMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraFlashMode_write", _wrap_PropertyICameraFlashMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraFlashMode", _wrap_delete_PropertyICameraFlashMode, METH_O, NULL},
	 { "PropertyICameraFlashMode_swigregister", PropertyICameraFlashMode_swigregister, METH_O, NULL},
	 { "PropertyICameraFlashMode_swiginit", PropertyICameraFlashMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraFlashMode", _wrap_new_pairstringTCameraFlashMode, METH_VARARGS, NULL},
	 { "pairstringTCameraFlashMode_first_set", _wrap_pairstringTCameraFlashMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraFlashMode_first_get", _wrap_pairstringTCameraFlashMode_first_get, METH_O, NULL},
	 { "pairstringTCameraFlashMode_second_set", _wrap_pairstringTCameraFlashMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraFlashMode_second_get", _wrap_pairstringTCameraFlashMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraFlashMode", _wrap_delete_pairstringTCameraFlashMode, METH_O, NULL},
	 { "pairstringTCameraFlashMode_swigregister", pairstringTCameraFlashMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraFlashMode_swiginit", pairstringTCameraFlashMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraFlashType", _wrap_new_PropertyICameraFlashType, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraFlashType_getTranslationDict", _wrap_PropertyICameraFlashType_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraFlashType_getTranslationDictString", _wrap_PropertyICameraFlashType_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraFlashType_getTranslationDictValue", _wrap_PropertyICameraFlashType_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraFlashType_getTranslationDictStrings", _wrap_PropertyICameraFlashType_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraFlashType_getTranslationDictValues", _wrap_PropertyICameraFlashType_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraFlashType_getMaxValue", _wrap_PropertyICameraFlashType_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraFlashType_getMinValue", _wrap_PropertyICameraFlashType_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraFlashType_getStepWidth", _wrap_PropertyICameraFlashType_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraFlashType_read", _wrap_PropertyICameraFlashType_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraFlashType_write", _wrap_PropertyICameraFlashType_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraFlashType", _wrap_delete_PropertyICameraFlashType, METH_O, NULL},
	 { "PropertyICameraFlashType_swigregister", PropertyICameraFlashType_swigregister, METH_O, NULL},
	 { "PropertyICameraFlashType_swiginit", PropertyICameraFlashType_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraFlashType", _wrap_new_pairstringTCameraFlashType, METH_VARARGS, NULL},
	 { "pairstringTCameraFlashType_first_set", _wrap_pairstringTCameraFlashType_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraFlashType_first_get", _wrap_pairstringTCameraFlashType_first_get, METH_O, NULL},
	 { "pairstringTCameraFlashType_second_set", _wrap_pairstringTCameraFlashType_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraFlashType_second_get", _wrap_pairstringTCameraFlashType_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraFlashType", _wrap_delete_pairstringTCameraFlashType, METH_O, NULL},
	 { "pairstringTCameraFlashType_swigregister", pairstringTCameraFlashType_swigregister, METH_O, NULL},
	 { "pairstringTCameraFlashType_swiginit", pairstringTCameraFlashType_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraHDRMode", _wrap_new_PropertyICameraHDRMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraHDRMode_getTranslationDict", _wrap_PropertyICameraHDRMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraHDRMode_getTranslationDictString", _wrap_PropertyICameraHDRMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraHDRMode_getTranslationDictValue", _wrap_PropertyICameraHDRMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraHDRMode_getTranslationDictStrings", _wrap_PropertyICameraHDRMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraHDRMode_getTranslationDictValues", _wrap_PropertyICameraHDRMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraHDRMode_getMaxValue", _wrap_PropertyICameraHDRMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraHDRMode_getMinValue", _wrap_PropertyICameraHDRMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraHDRMode_getStepWidth", _wrap_PropertyICameraHDRMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraHDRMode_read", _wrap_PropertyICameraHDRMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraHDRMode_write", _wrap_PropertyICameraHDRMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraHDRMode", _wrap_delete_PropertyICameraHDRMode, METH_O, NULL},
	 { "PropertyICameraHDRMode_swigregister", PropertyICameraHDRMode_swigregister, METH_O, NULL},
	 { "PropertyICameraHDRMode_swiginit", PropertyICameraHDRMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraHDRMode", _wrap_new_pairstringTCameraHDRMode, METH_VARARGS, NULL},
	 { "pairstringTCameraHDRMode_first_set", _wrap_pairstringTCameraHDRMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraHDRMode_first_get", _wrap_pairstringTCameraHDRMode_first_get, METH_O, NULL},
	 { "pairstringTCameraHDRMode_second_set", _wrap_pairstringTCameraHDRMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraHDRMode_second_get", _wrap_pairstringTCameraHDRMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraHDRMode", _wrap_delete_pairstringTCameraHDRMode, METH_O, NULL},
	 { "pairstringTCameraHDRMode_swigregister", pairstringTCameraHDRMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraHDRMode_swiginit", pairstringTCameraHDRMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraInterlacedType", _wrap_new_PropertyICameraInterlacedType, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraInterlacedType_getTranslationDict", _wrap_PropertyICameraInterlacedType_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraInterlacedType_getTranslationDictString", _wrap_PropertyICameraInterlacedType_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraInterlacedType_getTranslationDictValue", _wrap_PropertyICameraInterlacedType_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraInterlacedType_getTranslationDictStrings", _wrap_PropertyICameraInterlacedType_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraInterlacedType_getTranslationDictValues", _wrap_PropertyICameraInterlacedType_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraInterlacedType_getMaxValue", _wrap_PropertyICameraInterlacedType_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraInterlacedType_getMinValue", _wrap_PropertyICameraInterlacedType_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraInterlacedType_getStepWidth", _wrap_PropertyICameraInterlacedType_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraInterlacedType_read", _wrap_PropertyICameraInterlacedType_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraInterlacedType_write", _wrap_PropertyICameraInterlacedType_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraInterlacedType", _wrap_delete_PropertyICameraInterlacedType, METH_O, NULL},
	 { "PropertyICameraInterlacedType_swigregister", PropertyICameraInterlacedType_swigregister, METH_O, NULL},
	 { "PropertyICameraInterlacedType_swiginit", PropertyICameraInterlacedType_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraInterlacedType", _wrap_new_pairstringTCameraInterlacedType, METH_VARARGS, NULL},
	 { "pairstringTCameraInterlacedType_first_set", _wrap_pairstringTCameraInterlacedType_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraInterlacedType_first_get", _wrap_pairstringTCameraInterlacedType_first_get, METH_O, NULL},
	 { "pairstringTCameraInterlacedType_second_set", _wrap_pairstringTCameraInterlacedType_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraInterlacedType_second_get", _wrap_pairstringTCameraInterlacedType_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraInterlacedType", _wrap_delete_pairstringTCameraInterlacedType, METH_O, NULL},
	 { "pairstringTCameraInterlacedType_swigregister", pairstringTCameraInterlacedType_swigregister, METH_O, NULL},
	 { "pairstringTCameraInterlacedType_swiginit", pairstringTCameraInterlacedType_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraLinkDataValidMode", _wrap_new_PropertyICameraLinkDataValidMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraLinkDataValidMode_getTranslationDict", _wrap_PropertyICameraLinkDataValidMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraLinkDataValidMode_getTranslationDictString", _wrap_PropertyICameraLinkDataValidMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraLinkDataValidMode_getTranslationDictValue", _wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraLinkDataValidMode_getTranslationDictStrings", _wrap_PropertyICameraLinkDataValidMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraLinkDataValidMode_getTranslationDictValues", _wrap_PropertyICameraLinkDataValidMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraLinkDataValidMode_getMaxValue", _wrap_PropertyICameraLinkDataValidMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraLinkDataValidMode_getMinValue", _wrap_PropertyICameraLinkDataValidMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraLinkDataValidMode_getStepWidth", _wrap_PropertyICameraLinkDataValidMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraLinkDataValidMode_read", _wrap_PropertyICameraLinkDataValidMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraLinkDataValidMode_write", _wrap_PropertyICameraLinkDataValidMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraLinkDataValidMode", _wrap_delete_PropertyICameraLinkDataValidMode, METH_O, NULL},
	 { "PropertyICameraLinkDataValidMode_swigregister", PropertyICameraLinkDataValidMode_swigregister, METH_O, NULL},
	 { "PropertyICameraLinkDataValidMode_swiginit", PropertyICameraLinkDataValidMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraLinkDataValidMode", _wrap_new_pairstringTCameraLinkDataValidMode, METH_VARARGS, NULL},
	 { "pairstringTCameraLinkDataValidMode_first_set", _wrap_pairstringTCameraLinkDataValidMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraLinkDataValidMode_first_get", _wrap_pairstringTCameraLinkDataValidMode_first_get, METH_O, NULL},
	 { "pairstringTCameraLinkDataValidMode_second_set", _wrap_pairstringTCameraLinkDataValidMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraLinkDataValidMode_second_get", _wrap_pairstringTCameraLinkDataValidMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraLinkDataValidMode", _wrap_delete_pairstringTCameraLinkDataValidMode, METH_O, NULL},
	 { "pairstringTCameraLinkDataValidMode_swigregister", pairstringTCameraLinkDataValidMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraLinkDataValidMode_swiginit", pairstringTCameraLinkDataValidMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraOutput", _wrap_new_PropertyICameraOutput, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraOutput_getTranslationDict", _wrap_PropertyICameraOutput_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraOutput >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraOutput_getTranslationDictString", _wrap_PropertyICameraOutput_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraOutput_getTranslationDictValue", _wrap_PropertyICameraOutput_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraOutput_getTranslationDictStrings", _wrap_PropertyICameraOutput_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraOutput_getTranslationDictValues", _wrap_PropertyICameraOutput_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraOutput_getMaxValue", _wrap_PropertyICameraOutput_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraOutput_getMinValue", _wrap_PropertyICameraOutput_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraOutput_getStepWidth", _wrap_PropertyICameraOutput_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraOutput_read", _wrap_PropertyICameraOutput_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraOutput_write", _wrap_PropertyICameraOutput_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraOutput", _wrap_delete_PropertyICameraOutput, METH_O, NULL},
	 { "PropertyICameraOutput_swigregister", PropertyICameraOutput_swigregister, METH_O, NULL},
	 { "PropertyICameraOutput_swiginit", PropertyICameraOutput_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraOutput", _wrap_new_pairstringTCameraOutput, METH_VARARGS, NULL},
	 { "pairstringTCameraOutput_first_set", _wrap_pairstringTCameraOutput_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraOutput_first_get", _wrap_pairstringTCameraOutput_first_get, METH_O, NULL},
	 { "pairstringTCameraOutput_second_set", _wrap_pairstringTCameraOutput_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraOutput_second_get", _wrap_pairstringTCameraOutput_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraOutput", _wrap_delete_pairstringTCameraOutput, METH_O, NULL},
	 { "pairstringTCameraOutput_swigregister", pairstringTCameraOutput_swigregister, METH_O, NULL},
	 { "pairstringTCameraOutput_swiginit", pairstringTCameraOutput_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraPixelClock", _wrap_new_PropertyICameraPixelClock, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraPixelClock_getTranslationDict", _wrap_PropertyICameraPixelClock_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraPixelClock_getTranslationDictString", _wrap_PropertyICameraPixelClock_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraPixelClock_getTranslationDictValue", _wrap_PropertyICameraPixelClock_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraPixelClock_getTranslationDictStrings", _wrap_PropertyICameraPixelClock_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraPixelClock_getTranslationDictValues", _wrap_PropertyICameraPixelClock_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraPixelClock_getMaxValue", _wrap_PropertyICameraPixelClock_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraPixelClock_getMinValue", _wrap_PropertyICameraPixelClock_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraPixelClock_getStepWidth", _wrap_PropertyICameraPixelClock_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraPixelClock_read", _wrap_PropertyICameraPixelClock_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraPixelClock_write", _wrap_PropertyICameraPixelClock_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraPixelClock", _wrap_delete_PropertyICameraPixelClock, METH_O, NULL},
	 { "PropertyICameraPixelClock_swigregister", PropertyICameraPixelClock_swigregister, METH_O, NULL},
	 { "PropertyICameraPixelClock_swiginit", PropertyICameraPixelClock_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraPixelClock", _wrap_new_pairstringTCameraPixelClock, METH_VARARGS, NULL},
	 { "pairstringTCameraPixelClock_first_set", _wrap_pairstringTCameraPixelClock_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraPixelClock_first_get", _wrap_pairstringTCameraPixelClock_first_get, METH_O, NULL},
	 { "pairstringTCameraPixelClock_second_set", _wrap_pairstringTCameraPixelClock_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraPixelClock_second_get", _wrap_pairstringTCameraPixelClock_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraPixelClock", _wrap_delete_pairstringTCameraPixelClock, METH_O, NULL},
	 { "pairstringTCameraPixelClock_swigregister", pairstringTCameraPixelClock_swigregister, METH_O, NULL},
	 { "pairstringTCameraPixelClock_swiginit", pairstringTCameraPixelClock_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraScanMode", _wrap_new_PropertyICameraScanMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraScanMode_getTranslationDict", _wrap_PropertyICameraScanMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraScanMode_getTranslationDictString", _wrap_PropertyICameraScanMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraScanMode_getTranslationDictValue", _wrap_PropertyICameraScanMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraScanMode_getTranslationDictStrings", _wrap_PropertyICameraScanMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraScanMode_getTranslationDictValues", _wrap_PropertyICameraScanMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraScanMode_getMaxValue", _wrap_PropertyICameraScanMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraScanMode_getMinValue", _wrap_PropertyICameraScanMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraScanMode_getStepWidth", _wrap_PropertyICameraScanMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraScanMode_read", _wrap_PropertyICameraScanMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraScanMode_write", _wrap_PropertyICameraScanMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraScanMode", _wrap_delete_PropertyICameraScanMode, METH_O, NULL},
	 { "PropertyICameraScanMode_swigregister", PropertyICameraScanMode_swigregister, METH_O, NULL},
	 { "PropertyICameraScanMode_swiginit", PropertyICameraScanMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraScanMode", _wrap_new_pairstringTCameraScanMode, METH_VARARGS, NULL},
	 { "pairstringTCameraScanMode_first_set", _wrap_pairstringTCameraScanMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraScanMode_first_get", _wrap_pairstringTCameraScanMode_first_get, METH_O, NULL},
	 { "pairstringTCameraScanMode_second_set", _wrap_pairstringTCameraScanMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraScanMode_second_get", _wrap_pairstringTCameraScanMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraScanMode", _wrap_delete_pairstringTCameraScanMode, METH_O, NULL},
	 { "pairstringTCameraScanMode_swigregister", pairstringTCameraScanMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraScanMode_swiginit", pairstringTCameraScanMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraSerialPortBaudRate", _wrap_new_PropertyICameraSerialPortBaudRate, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_getTranslationDict", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_getTranslationDictString", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_getTranslationDictValue", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_getTranslationDictStrings", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_getTranslationDictValues", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_getMaxValue", _wrap_PropertyICameraSerialPortBaudRate_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_getMinValue", _wrap_PropertyICameraSerialPortBaudRate_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_getStepWidth", _wrap_PropertyICameraSerialPortBaudRate_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_read", _wrap_PropertyICameraSerialPortBaudRate_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraSerialPortBaudRate_write", _wrap_PropertyICameraSerialPortBaudRate_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraSerialPortBaudRate", _wrap_delete_PropertyICameraSerialPortBaudRate, METH_O, NULL},
	 { "PropertyICameraSerialPortBaudRate_swigregister", PropertyICameraSerialPortBaudRate_swigregister, METH_O, NULL},
	 { "PropertyICameraSerialPortBaudRate_swiginit", PropertyICameraSerialPortBaudRate_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraSerialPortBaudRate", _wrap_new_pairstringTCameraSerialPortBaudRate, METH_VARARGS, NULL},
	 { "pairstringTCameraSerialPortBaudRate_first_set", _wrap_pairstringTCameraSerialPortBaudRate_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraSerialPortBaudRate_first_get", _wrap_pairstringTCameraSerialPortBaudRate_first_get, METH_O, NULL},
	 { "pairstringTCameraSerialPortBaudRate_second_set", _wrap_pairstringTCameraSerialPortBaudRate_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraSerialPortBaudRate_second_get", _wrap_pairstringTCameraSerialPortBaudRate_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraSerialPortBaudRate", _wrap_delete_pairstringTCameraSerialPortBaudRate, METH_O, NULL},
	 { "pairstringTCameraSerialPortBaudRate_swigregister", pairstringTCameraSerialPortBaudRate_swigregister, METH_O, NULL},
	 { "pairstringTCameraSerialPortBaudRate_swiginit", pairstringTCameraSerialPortBaudRate_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraShutterMode", _wrap_new_PropertyICameraShutterMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraShutterMode_getTranslationDict", _wrap_PropertyICameraShutterMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraShutterMode_getTranslationDictString", _wrap_PropertyICameraShutterMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraShutterMode_getTranslationDictValue", _wrap_PropertyICameraShutterMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraShutterMode_getTranslationDictStrings", _wrap_PropertyICameraShutterMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraShutterMode_getTranslationDictValues", _wrap_PropertyICameraShutterMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraShutterMode_getMaxValue", _wrap_PropertyICameraShutterMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraShutterMode_getMinValue", _wrap_PropertyICameraShutterMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraShutterMode_getStepWidth", _wrap_PropertyICameraShutterMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraShutterMode_read", _wrap_PropertyICameraShutterMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraShutterMode_write", _wrap_PropertyICameraShutterMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraShutterMode", _wrap_delete_PropertyICameraShutterMode, METH_O, NULL},
	 { "PropertyICameraShutterMode_swigregister", PropertyICameraShutterMode_swigregister, METH_O, NULL},
	 { "PropertyICameraShutterMode_swiginit", PropertyICameraShutterMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraShutterMode", _wrap_new_pairstringTCameraShutterMode, METH_VARARGS, NULL},
	 { "pairstringTCameraShutterMode_first_set", _wrap_pairstringTCameraShutterMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraShutterMode_first_get", _wrap_pairstringTCameraShutterMode_first_get, METH_O, NULL},
	 { "pairstringTCameraShutterMode_second_set", _wrap_pairstringTCameraShutterMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraShutterMode_second_get", _wrap_pairstringTCameraShutterMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraShutterMode", _wrap_delete_pairstringTCameraShutterMode, METH_O, NULL},
	 { "pairstringTCameraShutterMode_swigregister", pairstringTCameraShutterMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraShutterMode_swiginit", pairstringTCameraShutterMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraTapsXGeometry", _wrap_new_PropertyICameraTapsXGeometry, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraTapsXGeometry_getTranslationDict", _wrap_PropertyICameraTapsXGeometry_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraTapsXGeometry_getTranslationDictString", _wrap_PropertyICameraTapsXGeometry_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTapsXGeometry_getTranslationDictValue", _wrap_PropertyICameraTapsXGeometry_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTapsXGeometry_getTranslationDictStrings", _wrap_PropertyICameraTapsXGeometry_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTapsXGeometry_getTranslationDictValues", _wrap_PropertyICameraTapsXGeometry_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTapsXGeometry_getMaxValue", _wrap_PropertyICameraTapsXGeometry_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTapsXGeometry_getMinValue", _wrap_PropertyICameraTapsXGeometry_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTapsXGeometry_getStepWidth", _wrap_PropertyICameraTapsXGeometry_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTapsXGeometry_read", _wrap_PropertyICameraTapsXGeometry_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraTapsXGeometry_write", _wrap_PropertyICameraTapsXGeometry_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraTapsXGeometry", _wrap_delete_PropertyICameraTapsXGeometry, METH_O, NULL},
	 { "PropertyICameraTapsXGeometry_swigregister", PropertyICameraTapsXGeometry_swigregister, METH_O, NULL},
	 { "PropertyICameraTapsXGeometry_swiginit", PropertyICameraTapsXGeometry_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraTapsXGeometry", _wrap_new_pairstringTCameraTapsXGeometry, METH_VARARGS, NULL},
	 { "pairstringTCameraTapsXGeometry_first_set", _wrap_pairstringTCameraTapsXGeometry_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTapsXGeometry_first_get", _wrap_pairstringTCameraTapsXGeometry_first_get, METH_O, NULL},
	 { "pairstringTCameraTapsXGeometry_second_set", _wrap_pairstringTCameraTapsXGeometry_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTapsXGeometry_second_get", _wrap_pairstringTCameraTapsXGeometry_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraTapsXGeometry", _wrap_delete_pairstringTCameraTapsXGeometry, METH_O, NULL},
	 { "pairstringTCameraTapsXGeometry_swigregister", pairstringTCameraTapsXGeometry_swigregister, METH_O, NULL},
	 { "pairstringTCameraTapsXGeometry_swiginit", pairstringTCameraTapsXGeometry_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraTapsYGeometry", _wrap_new_PropertyICameraTapsYGeometry, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraTapsYGeometry_getTranslationDict", _wrap_PropertyICameraTapsYGeometry_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraTapsYGeometry_getTranslationDictString", _wrap_PropertyICameraTapsYGeometry_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTapsYGeometry_getTranslationDictValue", _wrap_PropertyICameraTapsYGeometry_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTapsYGeometry_getTranslationDictStrings", _wrap_PropertyICameraTapsYGeometry_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTapsYGeometry_getTranslationDictValues", _wrap_PropertyICameraTapsYGeometry_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTapsYGeometry_getMaxValue", _wrap_PropertyICameraTapsYGeometry_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTapsYGeometry_getMinValue", _wrap_PropertyICameraTapsYGeometry_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTapsYGeometry_getStepWidth", _wrap_PropertyICameraTapsYGeometry_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTapsYGeometry_read", _wrap_PropertyICameraTapsYGeometry_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraTapsYGeometry_write", _wrap_PropertyICameraTapsYGeometry_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraTapsYGeometry", _wrap_delete_PropertyICameraTapsYGeometry, METH_O, NULL},
	 { "PropertyICameraTapsYGeometry_swigregister", PropertyICameraTapsYGeometry_swigregister, METH_O, NULL},
	 { "PropertyICameraTapsYGeometry_swiginit", PropertyICameraTapsYGeometry_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraTapsYGeometry", _wrap_new_pairstringTCameraTapsYGeometry, METH_VARARGS, NULL},
	 { "pairstringTCameraTapsYGeometry_first_set", _wrap_pairstringTCameraTapsYGeometry_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTapsYGeometry_first_get", _wrap_pairstringTCameraTapsYGeometry_first_get, METH_O, NULL},
	 { "pairstringTCameraTapsYGeometry_second_set", _wrap_pairstringTCameraTapsYGeometry_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTapsYGeometry_second_get", _wrap_pairstringTCameraTapsYGeometry_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraTapsYGeometry", _wrap_delete_pairstringTCameraTapsYGeometry, METH_O, NULL},
	 { "pairstringTCameraTapsYGeometry_swigregister", pairstringTCameraTapsYGeometry_swigregister, METH_O, NULL},
	 { "pairstringTCameraTapsYGeometry_swiginit", pairstringTCameraTapsYGeometry_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraTestMode", _wrap_new_PropertyICameraTestMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraTestMode_getTranslationDict", _wrap_PropertyICameraTestMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraTestMode_getTranslationDictString", _wrap_PropertyICameraTestMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTestMode_getTranslationDictValue", _wrap_PropertyICameraTestMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTestMode_getTranslationDictStrings", _wrap_PropertyICameraTestMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTestMode_getTranslationDictValues", _wrap_PropertyICameraTestMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTestMode_getMaxValue", _wrap_PropertyICameraTestMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTestMode_getMinValue", _wrap_PropertyICameraTestMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTestMode_getStepWidth", _wrap_PropertyICameraTestMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTestMode_read", _wrap_PropertyICameraTestMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraTestMode_write", _wrap_PropertyICameraTestMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraTestMode", _wrap_delete_PropertyICameraTestMode, METH_O, NULL},
	 { "PropertyICameraTestMode_swigregister", PropertyICameraTestMode_swigregister, METH_O, NULL},
	 { "PropertyICameraTestMode_swiginit", PropertyICameraTestMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraTestMode", _wrap_new_pairstringTCameraTestMode, METH_VARARGS, NULL},
	 { "pairstringTCameraTestMode_first_set", _wrap_pairstringTCameraTestMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTestMode_first_get", _wrap_pairstringTCameraTestMode_first_get, METH_O, NULL},
	 { "pairstringTCameraTestMode_second_set", _wrap_pairstringTCameraTestMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTestMode_second_get", _wrap_pairstringTCameraTestMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraTestMode", _wrap_delete_pairstringTCameraTestMode, METH_O, NULL},
	 { "pairstringTCameraTestMode_swigregister", pairstringTCameraTestMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraTestMode_swiginit", pairstringTCameraTestMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraTriggerMode", _wrap_new_PropertyICameraTriggerMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraTriggerMode_getTranslationDict", _wrap_PropertyICameraTriggerMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraTriggerMode_getTranslationDictString", _wrap_PropertyICameraTriggerMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTriggerMode_getTranslationDictValue", _wrap_PropertyICameraTriggerMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTriggerMode_getTranslationDictStrings", _wrap_PropertyICameraTriggerMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTriggerMode_getTranslationDictValues", _wrap_PropertyICameraTriggerMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTriggerMode_getMaxValue", _wrap_PropertyICameraTriggerMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTriggerMode_getMinValue", _wrap_PropertyICameraTriggerMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTriggerMode_getStepWidth", _wrap_PropertyICameraTriggerMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTriggerMode_read", _wrap_PropertyICameraTriggerMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraTriggerMode_write", _wrap_PropertyICameraTriggerMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraTriggerMode", _wrap_delete_PropertyICameraTriggerMode, METH_O, NULL},
	 { "PropertyICameraTriggerMode_swigregister", PropertyICameraTriggerMode_swigregister, METH_O, NULL},
	 { "PropertyICameraTriggerMode_swiginit", PropertyICameraTriggerMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraTriggerMode", _wrap_new_pairstringTCameraTriggerMode, METH_VARARGS, NULL},
	 { "pairstringTCameraTriggerMode_first_set", _wrap_pairstringTCameraTriggerMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTriggerMode_first_get", _wrap_pairstringTCameraTriggerMode_first_get, METH_O, NULL},
	 { "pairstringTCameraTriggerMode_second_set", _wrap_pairstringTCameraTriggerMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTriggerMode_second_get", _wrap_pairstringTCameraTriggerMode_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraTriggerMode", _wrap_delete_pairstringTCameraTriggerMode, METH_O, NULL},
	 { "pairstringTCameraTriggerMode_swigregister", pairstringTCameraTriggerMode_swigregister, METH_O, NULL},
	 { "pairstringTCameraTriggerMode_swiginit", pairstringTCameraTriggerMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyICameraTriggerSource", _wrap_new_PropertyICameraTriggerSource, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyICameraTriggerSource_getTranslationDict", _wrap_PropertyICameraTriggerSource_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyICameraTriggerSource_getTranslationDictString", _wrap_PropertyICameraTriggerSource_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTriggerSource_getTranslationDictValue", _wrap_PropertyICameraTriggerSource_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyICameraTriggerSource_getTranslationDictStrings", _wrap_PropertyICameraTriggerSource_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTriggerSource_getTranslationDictValues", _wrap_PropertyICameraTriggerSource_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyICameraTriggerSource_getMaxValue", _wrap_PropertyICameraTriggerSource_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTriggerSource_getMinValue", _wrap_PropertyICameraTriggerSource_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTriggerSource_getStepWidth", _wrap_PropertyICameraTriggerSource_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyICameraTriggerSource_read", _wrap_PropertyICameraTriggerSource_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyICameraTriggerSource_write", _wrap_PropertyICameraTriggerSource_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyICameraTriggerSource", _wrap_delete_PropertyICameraTriggerSource, METH_O, NULL},
	 { "PropertyICameraTriggerSource_swigregister", PropertyICameraTriggerSource_swigregister, METH_O, NULL},
	 { "PropertyICameraTriggerSource_swiginit", PropertyICameraTriggerSource_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTCameraTriggerSource", _wrap_new_pairstringTCameraTriggerSource, METH_VARARGS, NULL},
	 { "pairstringTCameraTriggerSource_first_set", _wrap_pairstringTCameraTriggerSource_first_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTriggerSource_first_get", _wrap_pairstringTCameraTriggerSource_first_get, METH_O, NULL},
	 { "pairstringTCameraTriggerSource_second_set", _wrap_pairstringTCameraTriggerSource_second_set, METH_VARARGS, NULL},
	 { "pairstringTCameraTriggerSource_second_get", _wrap_pairstringTCameraTriggerSource_second_get, METH_O, NULL},
	 { "delete_pairstringTCameraTriggerSource", _wrap_delete_pairstringTCameraTriggerSource, METH_O, NULL},
	 { "pairstringTCameraTriggerSource_swigregister", pairstringTCameraTriggerSource_swigregister, METH_O, NULL},
	 { "pairstringTCameraTriggerSource_swiginit", pairstringTCameraTriggerSource_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIChannelSplitMode", _wrap_new_PropertyIChannelSplitMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIChannelSplitMode_getTranslationDict", _wrap_PropertyIChannelSplitMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIChannelSplitMode_getTranslationDictString", _wrap_PropertyIChannelSplitMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIChannelSplitMode_getTranslationDictValue", _wrap_PropertyIChannelSplitMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIChannelSplitMode_getTranslationDictStrings", _wrap_PropertyIChannelSplitMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIChannelSplitMode_getTranslationDictValues", _wrap_PropertyIChannelSplitMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIChannelSplitMode_getMaxValue", _wrap_PropertyIChannelSplitMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIChannelSplitMode_getMinValue", _wrap_PropertyIChannelSplitMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIChannelSplitMode_getStepWidth", _wrap_PropertyIChannelSplitMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIChannelSplitMode_read", _wrap_PropertyIChannelSplitMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIChannelSplitMode_write", _wrap_PropertyIChannelSplitMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIChannelSplitMode", _wrap_delete_PropertyIChannelSplitMode, METH_O, NULL},
	 { "PropertyIChannelSplitMode_swigregister", PropertyIChannelSplitMode_swigregister, METH_O, NULL},
	 { "PropertyIChannelSplitMode_swiginit", PropertyIChannelSplitMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTChannelSplitMode", _wrap_new_pairstringTChannelSplitMode, METH_VARARGS, NULL},
	 { "pairstringTChannelSplitMode_first_set", _wrap_pairstringTChannelSplitMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTChannelSplitMode_first_get", _wrap_pairstringTChannelSplitMode_first_get, METH_O, NULL},
	 { "pairstringTChannelSplitMode_second_set", _wrap_pairstringTChannelSplitMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTChannelSplitMode_second_get", _wrap_pairstringTChannelSplitMode_second_get, METH_O, NULL},
	 { "delete_pairstringTChannelSplitMode", _wrap_delete_pairstringTChannelSplitMode, METH_O, NULL},
	 { "pairstringTChannelSplitMode_swigregister", pairstringTChannelSplitMode_swigregister, METH_O, NULL},
	 { "pairstringTChannelSplitMode_swiginit", pairstringTChannelSplitMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIClampMode", _wrap_new_PropertyIClampMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIClampMode_getTranslationDict", _wrap_PropertyIClampMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TClampMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TClampMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIClampMode_getTranslationDictString", _wrap_PropertyIClampMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIClampMode_getTranslationDictValue", _wrap_PropertyIClampMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIClampMode_getTranslationDictStrings", _wrap_PropertyIClampMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIClampMode_getTranslationDictValues", _wrap_PropertyIClampMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIClampMode_getMaxValue", _wrap_PropertyIClampMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIClampMode_getMinValue", _wrap_PropertyIClampMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIClampMode_getStepWidth", _wrap_PropertyIClampMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIClampMode_read", _wrap_PropertyIClampMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIClampMode_write", _wrap_PropertyIClampMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIClampMode", _wrap_delete_PropertyIClampMode, METH_O, NULL},
	 { "PropertyIClampMode_swigregister", PropertyIClampMode_swigregister, METH_O, NULL},
	 { "PropertyIClampMode_swiginit", PropertyIClampMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTClampMode", _wrap_new_pairstringTClampMode, METH_VARARGS, NULL},
	 { "pairstringTClampMode_first_set", _wrap_pairstringTClampMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTClampMode_first_get", _wrap_pairstringTClampMode_first_get, METH_O, NULL},
	 { "pairstringTClampMode_second_set", _wrap_pairstringTClampMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTClampMode_second_get", _wrap_pairstringTClampMode_second_get, METH_O, NULL},
	 { "delete_pairstringTClampMode", _wrap_delete_pairstringTClampMode, METH_O, NULL},
	 { "pairstringTClampMode_swigregister", pairstringTClampMode_swigregister, METH_O, NULL},
	 { "pairstringTClampMode_swiginit", pairstringTClampMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIColorTwistInputCorrectionMatrixMode", _wrap_new_PropertyIColorTwistInputCorrectionMatrixMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValues", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_getMaxValue", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_getMinValue", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_getStepWidth", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_read", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_write", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIColorTwistInputCorrectionMatrixMode", _wrap_delete_PropertyIColorTwistInputCorrectionMatrixMode, METH_O, NULL},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_swigregister", PropertyIColorTwistInputCorrectionMatrixMode_swigregister, METH_O, NULL},
	 { "PropertyIColorTwistInputCorrectionMatrixMode_swiginit", PropertyIColorTwistInputCorrectionMatrixMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTColorTwistInputCorrectionMatrixMode", _wrap_new_pairstringTColorTwistInputCorrectionMatrixMode, METH_VARARGS, NULL},
	 { "pairstringTColorTwistInputCorrectionMatrixMode_first_set", _wrap_pairstringTColorTwistInputCorrectionMatrixMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTColorTwistInputCorrectionMatrixMode_first_get", _wrap_pairstringTColorTwistInputCorrectionMatrixMode_first_get, METH_O, NULL},
	 { "pairstringTColorTwistInputCorrectionMatrixMode_second_set", _wrap_pairstringTColorTwistInputCorrectionMatrixMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTColorTwistInputCorrectionMatrixMode_second_get", _wrap_pairstringTColorTwistInputCorrectionMatrixMode_second_get, METH_O, NULL},
	 { "delete_pairstringTColorTwistInputCorrectionMatrixMode", _wrap_delete_pairstringTColorTwistInputCorrectionMatrixMode, METH_O, NULL},
	 { "pairstringTColorTwistInputCorrectionMatrixMode_swigregister", pairstringTColorTwistInputCorrectionMatrixMode_swigregister, METH_O, NULL},
	 { "pairstringTColorTwistInputCorrectionMatrixMode_swiginit", pairstringTColorTwistInputCorrectionMatrixMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIColorTwistOutputCorrectionMatrixMode", _wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValues", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_getMaxValue", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_getMinValue", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_getStepWidth", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_read", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_write", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIColorTwistOutputCorrectionMatrixMode", _wrap_delete_PropertyIColorTwistOutputCorrectionMatrixMode, METH_O, NULL},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_swigregister", PropertyIColorTwistOutputCorrectionMatrixMode_swigregister, METH_O, NULL},
	 { "PropertyIColorTwistOutputCorrectionMatrixMode_swiginit", PropertyIColorTwistOutputCorrectionMatrixMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTColorTwistOutputCorrectionMatrixMode", _wrap_new_pairstringTColorTwistOutputCorrectionMatrixMode, METH_VARARGS, NULL},
	 { "pairstringTColorTwistOutputCorrectionMatrixMode_first_set", _wrap_pairstringTColorTwistOutputCorrectionMatrixMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTColorTwistOutputCorrectionMatrixMode_first_get", _wrap_pairstringTColorTwistOutputCorrectionMatrixMode_first_get, METH_O, NULL},
	 { "pairstringTColorTwistOutputCorrectionMatrixMode_second_set", _wrap_pairstringTColorTwistOutputCorrectionMatrixMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTColorTwistOutputCorrectionMatrixMode_second_get", _wrap_pairstringTColorTwistOutputCorrectionMatrixMode_second_get, METH_O, NULL},
	 { "delete_pairstringTColorTwistOutputCorrectionMatrixMode", _wrap_delete_pairstringTColorTwistOutputCorrectionMatrixMode, METH_O, NULL},
	 { "pairstringTColorTwistOutputCorrectionMatrixMode_swigregister", pairstringTColorTwistOutputCorrectionMatrixMode_swigregister, METH_O, NULL},
	 { "pairstringTColorTwistOutputCorrectionMatrixMode_swiginit", pairstringTColorTwistOutputCorrectionMatrixMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIColorProcessingMode", _wrap_new_PropertyIColorProcessingMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIColorProcessingMode_getTranslationDict", _wrap_PropertyIColorProcessingMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIColorProcessingMode_getTranslationDictString", _wrap_PropertyIColorProcessingMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIColorProcessingMode_getTranslationDictValue", _wrap_PropertyIColorProcessingMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIColorProcessingMode_getTranslationDictStrings", _wrap_PropertyIColorProcessingMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIColorProcessingMode_getTranslationDictValues", _wrap_PropertyIColorProcessingMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIColorProcessingMode_getMaxValue", _wrap_PropertyIColorProcessingMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIColorProcessingMode_getMinValue", _wrap_PropertyIColorProcessingMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIColorProcessingMode_getStepWidth", _wrap_PropertyIColorProcessingMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIColorProcessingMode_read", _wrap_PropertyIColorProcessingMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIColorProcessingMode_write", _wrap_PropertyIColorProcessingMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIColorProcessingMode", _wrap_delete_PropertyIColorProcessingMode, METH_O, NULL},
	 { "PropertyIColorProcessingMode_swigregister", PropertyIColorProcessingMode_swigregister, METH_O, NULL},
	 { "PropertyIColorProcessingMode_swiginit", PropertyIColorProcessingMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTColorProcessingMode", _wrap_new_pairstringTColorProcessingMode, METH_VARARGS, NULL},
	 { "pairstringTColorProcessingMode_first_set", _wrap_pairstringTColorProcessingMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTColorProcessingMode_first_get", _wrap_pairstringTColorProcessingMode_first_get, METH_O, NULL},
	 { "pairstringTColorProcessingMode_second_set", _wrap_pairstringTColorProcessingMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTColorProcessingMode_second_get", _wrap_pairstringTColorProcessingMode_second_get, METH_O, NULL},
	 { "delete_pairstringTColorProcessingMode", _wrap_delete_pairstringTColorProcessingMode, METH_O, NULL},
	 { "pairstringTColorProcessingMode_swigregister", pairstringTColorProcessingMode_swigregister, METH_O, NULL},
	 { "pairstringTColorProcessingMode_swiginit", pairstringTColorProcessingMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDarkCurrentFilterMode", _wrap_new_PropertyIDarkCurrentFilterMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_getTranslationDict", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_getTranslationDictString", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_getTranslationDictValue", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_getTranslationDictStrings", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_getTranslationDictValues", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_getMaxValue", _wrap_PropertyIDarkCurrentFilterMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_getMinValue", _wrap_PropertyIDarkCurrentFilterMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_getStepWidth", _wrap_PropertyIDarkCurrentFilterMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_read", _wrap_PropertyIDarkCurrentFilterMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDarkCurrentFilterMode_write", _wrap_PropertyIDarkCurrentFilterMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDarkCurrentFilterMode", _wrap_delete_PropertyIDarkCurrentFilterMode, METH_O, NULL},
	 { "PropertyIDarkCurrentFilterMode_swigregister", PropertyIDarkCurrentFilterMode_swigregister, METH_O, NULL},
	 { "PropertyIDarkCurrentFilterMode_swiginit", PropertyIDarkCurrentFilterMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDarkCurrentFilterMode", _wrap_new_pairstringTDarkCurrentFilterMode, METH_VARARGS, NULL},
	 { "pairstringTDarkCurrentFilterMode_first_set", _wrap_pairstringTDarkCurrentFilterMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDarkCurrentFilterMode_first_get", _wrap_pairstringTDarkCurrentFilterMode_first_get, METH_O, NULL},
	 { "pairstringTDarkCurrentFilterMode_second_set", _wrap_pairstringTDarkCurrentFilterMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDarkCurrentFilterMode_second_get", _wrap_pairstringTDarkCurrentFilterMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDarkCurrentFilterMode", _wrap_delete_pairstringTDarkCurrentFilterMode, METH_O, NULL},
	 { "pairstringTDarkCurrentFilterMode_swigregister", pairstringTDarkCurrentFilterMode_swigregister, METH_O, NULL},
	 { "pairstringTDarkCurrentFilterMode_swiginit", pairstringTDarkCurrentFilterMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDefectivePixelsFilterMode", _wrap_new_PropertyIDefectivePixelsFilterMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_getTranslationDict", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_getTranslationDictString", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_getTranslationDictValue", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_getTranslationDictStrings", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_getTranslationDictValues", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_getMaxValue", _wrap_PropertyIDefectivePixelsFilterMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_getMinValue", _wrap_PropertyIDefectivePixelsFilterMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_getStepWidth", _wrap_PropertyIDefectivePixelsFilterMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_read", _wrap_PropertyIDefectivePixelsFilterMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDefectivePixelsFilterMode_write", _wrap_PropertyIDefectivePixelsFilterMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDefectivePixelsFilterMode", _wrap_delete_PropertyIDefectivePixelsFilterMode, METH_O, NULL},
	 { "PropertyIDefectivePixelsFilterMode_swigregister", PropertyIDefectivePixelsFilterMode_swigregister, METH_O, NULL},
	 { "PropertyIDefectivePixelsFilterMode_swiginit", PropertyIDefectivePixelsFilterMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDefectivePixelsFilterMode", _wrap_new_pairstringTDefectivePixelsFilterMode, METH_VARARGS, NULL},
	 { "pairstringTDefectivePixelsFilterMode_first_set", _wrap_pairstringTDefectivePixelsFilterMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDefectivePixelsFilterMode_first_get", _wrap_pairstringTDefectivePixelsFilterMode_first_get, METH_O, NULL},
	 { "pairstringTDefectivePixelsFilterMode_second_set", _wrap_pairstringTDefectivePixelsFilterMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDefectivePixelsFilterMode_second_get", _wrap_pairstringTDefectivePixelsFilterMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDefectivePixelsFilterMode", _wrap_delete_pairstringTDefectivePixelsFilterMode, METH_O, NULL},
	 { "pairstringTDefectivePixelsFilterMode_swigregister", pairstringTDefectivePixelsFilterMode_swigregister, METH_O, NULL},
	 { "pairstringTDefectivePixelsFilterMode_swiginit", pairstringTDefectivePixelsFilterMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceAccessMode", _wrap_new_PropertyIDeviceAccessMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceAccessMode_getTranslationDict", _wrap_PropertyIDeviceAccessMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceAccessMode_getTranslationDictString", _wrap_PropertyIDeviceAccessMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceAccessMode_getTranslationDictValue", _wrap_PropertyIDeviceAccessMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceAccessMode_getTranslationDictStrings", _wrap_PropertyIDeviceAccessMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceAccessMode_getTranslationDictValues", _wrap_PropertyIDeviceAccessMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceAccessMode_getMaxValue", _wrap_PropertyIDeviceAccessMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceAccessMode_getMinValue", _wrap_PropertyIDeviceAccessMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceAccessMode_getStepWidth", _wrap_PropertyIDeviceAccessMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceAccessMode_read", _wrap_PropertyIDeviceAccessMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceAccessMode_write", _wrap_PropertyIDeviceAccessMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceAccessMode", _wrap_delete_PropertyIDeviceAccessMode, METH_O, NULL},
	 { "PropertyIDeviceAccessMode_swigregister", PropertyIDeviceAccessMode_swigregister, METH_O, NULL},
	 { "PropertyIDeviceAccessMode_swiginit", PropertyIDeviceAccessMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceAccessMode", _wrap_new_pairstringTDeviceAccessMode, METH_VARARGS, NULL},
	 { "pairstringTDeviceAccessMode_first_set", _wrap_pairstringTDeviceAccessMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceAccessMode_first_get", _wrap_pairstringTDeviceAccessMode_first_get, METH_O, NULL},
	 { "pairstringTDeviceAccessMode_second_set", _wrap_pairstringTDeviceAccessMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceAccessMode_second_get", _wrap_pairstringTDeviceAccessMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceAccessMode", _wrap_delete_pairstringTDeviceAccessMode, METH_O, NULL},
	 { "pairstringTDeviceAccessMode_swigregister", pairstringTDeviceAccessMode_swigregister, METH_O, NULL},
	 { "pairstringTDeviceAccessMode_swiginit", pairstringTDeviceAccessMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceAdvancedOptions", _wrap_new_PropertyIDeviceAdvancedOptions, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_getTranslationDict", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_getTranslationDictString", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_getTranslationDictValue", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_getTranslationDictStrings", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_getTranslationDictValues", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_getMaxValue", _wrap_PropertyIDeviceAdvancedOptions_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_getMinValue", _wrap_PropertyIDeviceAdvancedOptions_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_getStepWidth", _wrap_PropertyIDeviceAdvancedOptions_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_read", _wrap_PropertyIDeviceAdvancedOptions_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceAdvancedOptions_write", _wrap_PropertyIDeviceAdvancedOptions_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceAdvancedOptions", _wrap_delete_PropertyIDeviceAdvancedOptions, METH_O, NULL},
	 { "PropertyIDeviceAdvancedOptions_swigregister", PropertyIDeviceAdvancedOptions_swigregister, METH_O, NULL},
	 { "PropertyIDeviceAdvancedOptions_swiginit", PropertyIDeviceAdvancedOptions_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceAdvancedOptions", _wrap_new_pairstringTDeviceAdvancedOptions, METH_VARARGS, NULL},
	 { "pairstringTDeviceAdvancedOptions_first_set", _wrap_pairstringTDeviceAdvancedOptions_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceAdvancedOptions_first_get", _wrap_pairstringTDeviceAdvancedOptions_first_get, METH_O, NULL},
	 { "pairstringTDeviceAdvancedOptions_second_set", _wrap_pairstringTDeviceAdvancedOptions_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceAdvancedOptions_second_get", _wrap_pairstringTDeviceAdvancedOptions_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceAdvancedOptions", _wrap_delete_pairstringTDeviceAdvancedOptions, METH_O, NULL},
	 { "pairstringTDeviceAdvancedOptions_swigregister", pairstringTDeviceAdvancedOptions_swigregister, METH_O, NULL},
	 { "pairstringTDeviceAdvancedOptions_swiginit", pairstringTDeviceAdvancedOptions_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceCapability", _wrap_new_PropertyIDeviceCapability, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceCapability_getTranslationDict", _wrap_PropertyIDeviceCapability_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceCapability_getTranslationDictString", _wrap_PropertyIDeviceCapability_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceCapability_getTranslationDictValue", _wrap_PropertyIDeviceCapability_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceCapability_getTranslationDictStrings", _wrap_PropertyIDeviceCapability_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceCapability_getTranslationDictValues", _wrap_PropertyIDeviceCapability_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceCapability_getMaxValue", _wrap_PropertyIDeviceCapability_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceCapability_getMinValue", _wrap_PropertyIDeviceCapability_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceCapability_getStepWidth", _wrap_PropertyIDeviceCapability_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceCapability_read", _wrap_PropertyIDeviceCapability_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceCapability_write", _wrap_PropertyIDeviceCapability_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceCapability", _wrap_delete_PropertyIDeviceCapability, METH_O, NULL},
	 { "PropertyIDeviceCapability_swigregister", PropertyIDeviceCapability_swigregister, METH_O, NULL},
	 { "PropertyIDeviceCapability_swiginit", PropertyIDeviceCapability_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceCapability", _wrap_new_pairstringTDeviceCapability, METH_VARARGS, NULL},
	 { "pairstringTDeviceCapability_first_set", _wrap_pairstringTDeviceCapability_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceCapability_first_get", _wrap_pairstringTDeviceCapability_first_get, METH_O, NULL},
	 { "pairstringTDeviceCapability_second_set", _wrap_pairstringTDeviceCapability_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceCapability_second_get", _wrap_pairstringTDeviceCapability_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceCapability", _wrap_delete_pairstringTDeviceCapability, METH_O, NULL},
	 { "pairstringTDeviceCapability_swigregister", pairstringTDeviceCapability_swigregister, METH_O, NULL},
	 { "pairstringTDeviceCapability_swiginit", pairstringTDeviceCapability_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceClass", _wrap_new_PropertyIDeviceClass, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceClass_getTranslationDict", _wrap_PropertyIDeviceClass_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceClass >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceClass_getTranslationDictString", _wrap_PropertyIDeviceClass_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceClass_getTranslationDictValue", _wrap_PropertyIDeviceClass_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceClass_getTranslationDictStrings", _wrap_PropertyIDeviceClass_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceClass_getTranslationDictValues", _wrap_PropertyIDeviceClass_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceClass_getMaxValue", _wrap_PropertyIDeviceClass_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceClass_getMinValue", _wrap_PropertyIDeviceClass_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceClass_getStepWidth", _wrap_PropertyIDeviceClass_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceClass_read", _wrap_PropertyIDeviceClass_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceClass_write", _wrap_PropertyIDeviceClass_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceClass", _wrap_delete_PropertyIDeviceClass, METH_O, NULL},
	 { "PropertyIDeviceClass_swigregister", PropertyIDeviceClass_swigregister, METH_O, NULL},
	 { "PropertyIDeviceClass_swiginit", PropertyIDeviceClass_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceClass", _wrap_new_pairstringTDeviceClass, METH_VARARGS, NULL},
	 { "pairstringTDeviceClass_first_set", _wrap_pairstringTDeviceClass_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceClass_first_get", _wrap_pairstringTDeviceClass_first_get, METH_O, NULL},
	 { "pairstringTDeviceClass_second_set", _wrap_pairstringTDeviceClass_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceClass_second_get", _wrap_pairstringTDeviceClass_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceClass", _wrap_delete_pairstringTDeviceClass, METH_O, NULL},
	 { "pairstringTDeviceClass_swigregister", pairstringTDeviceClass_swigregister, METH_O, NULL},
	 { "pairstringTDeviceClass_swiginit", pairstringTDeviceClass_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceDigitalOutputMode", _wrap_new_PropertyIDeviceDigitalOutputMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_getTranslationDict", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_getTranslationDictString", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_getTranslationDictValue", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_getTranslationDictStrings", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_getTranslationDictValues", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_getMaxValue", _wrap_PropertyIDeviceDigitalOutputMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_getMinValue", _wrap_PropertyIDeviceDigitalOutputMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_getStepWidth", _wrap_PropertyIDeviceDigitalOutputMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_read", _wrap_PropertyIDeviceDigitalOutputMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceDigitalOutputMode_write", _wrap_PropertyIDeviceDigitalOutputMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceDigitalOutputMode", _wrap_delete_PropertyIDeviceDigitalOutputMode, METH_O, NULL},
	 { "PropertyIDeviceDigitalOutputMode_swigregister", PropertyIDeviceDigitalOutputMode_swigregister, METH_O, NULL},
	 { "PropertyIDeviceDigitalOutputMode_swiginit", PropertyIDeviceDigitalOutputMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceDigitalOutputMode", _wrap_new_pairstringTDeviceDigitalOutputMode, METH_VARARGS, NULL},
	 { "pairstringTDeviceDigitalOutputMode_first_set", _wrap_pairstringTDeviceDigitalOutputMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceDigitalOutputMode_first_get", _wrap_pairstringTDeviceDigitalOutputMode_first_get, METH_O, NULL},
	 { "pairstringTDeviceDigitalOutputMode_second_set", _wrap_pairstringTDeviceDigitalOutputMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceDigitalOutputMode_second_get", _wrap_pairstringTDeviceDigitalOutputMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceDigitalOutputMode", _wrap_delete_pairstringTDeviceDigitalOutputMode, METH_O, NULL},
	 { "pairstringTDeviceDigitalOutputMode_swigregister", pairstringTDeviceDigitalOutputMode_swigregister, METH_O, NULL},
	 { "pairstringTDeviceDigitalOutputMode_swiginit", pairstringTDeviceDigitalOutputMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceImageTrigger", _wrap_new_PropertyIDeviceImageTrigger, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceImageTrigger_getTranslationDict", _wrap_PropertyIDeviceImageTrigger_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceImageTrigger_getTranslationDictString", _wrap_PropertyIDeviceImageTrigger_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceImageTrigger_getTranslationDictValue", _wrap_PropertyIDeviceImageTrigger_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceImageTrigger_getTranslationDictStrings", _wrap_PropertyIDeviceImageTrigger_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceImageTrigger_getTranslationDictValues", _wrap_PropertyIDeviceImageTrigger_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceImageTrigger_getMaxValue", _wrap_PropertyIDeviceImageTrigger_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceImageTrigger_getMinValue", _wrap_PropertyIDeviceImageTrigger_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceImageTrigger_getStepWidth", _wrap_PropertyIDeviceImageTrigger_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceImageTrigger_read", _wrap_PropertyIDeviceImageTrigger_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceImageTrigger_write", _wrap_PropertyIDeviceImageTrigger_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceImageTrigger", _wrap_delete_PropertyIDeviceImageTrigger, METH_O, NULL},
	 { "PropertyIDeviceImageTrigger_swigregister", PropertyIDeviceImageTrigger_swigregister, METH_O, NULL},
	 { "PropertyIDeviceImageTrigger_swiginit", PropertyIDeviceImageTrigger_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceImageTrigger", _wrap_new_pairstringTDeviceImageTrigger, METH_VARARGS, NULL},
	 { "pairstringTDeviceImageTrigger_first_set", _wrap_pairstringTDeviceImageTrigger_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceImageTrigger_first_get", _wrap_pairstringTDeviceImageTrigger_first_get, METH_O, NULL},
	 { "pairstringTDeviceImageTrigger_second_set", _wrap_pairstringTDeviceImageTrigger_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceImageTrigger_second_get", _wrap_pairstringTDeviceImageTrigger_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceImageTrigger", _wrap_delete_pairstringTDeviceImageTrigger, METH_O, NULL},
	 { "pairstringTDeviceImageTrigger_swigregister", pairstringTDeviceImageTrigger_swigregister, METH_O, NULL},
	 { "pairstringTDeviceImageTrigger_swiginit", pairstringTDeviceImageTrigger_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceInterfaceLayout", _wrap_new_PropertyIDeviceInterfaceLayout, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_getTranslationDict", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_getTranslationDictString", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_getTranslationDictValue", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_getTranslationDictStrings", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_getTranslationDictValues", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_getMaxValue", _wrap_PropertyIDeviceInterfaceLayout_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_getMinValue", _wrap_PropertyIDeviceInterfaceLayout_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_getStepWidth", _wrap_PropertyIDeviceInterfaceLayout_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_read", _wrap_PropertyIDeviceInterfaceLayout_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceInterfaceLayout_write", _wrap_PropertyIDeviceInterfaceLayout_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceInterfaceLayout", _wrap_delete_PropertyIDeviceInterfaceLayout, METH_O, NULL},
	 { "PropertyIDeviceInterfaceLayout_swigregister", PropertyIDeviceInterfaceLayout_swigregister, METH_O, NULL},
	 { "PropertyIDeviceInterfaceLayout_swiginit", PropertyIDeviceInterfaceLayout_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceInterfaceLayout", _wrap_new_pairstringTDeviceInterfaceLayout, METH_VARARGS, NULL},
	 { "pairstringTDeviceInterfaceLayout_first_set", _wrap_pairstringTDeviceInterfaceLayout_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceInterfaceLayout_first_get", _wrap_pairstringTDeviceInterfaceLayout_first_get, METH_O, NULL},
	 { "pairstringTDeviceInterfaceLayout_second_set", _wrap_pairstringTDeviceInterfaceLayout_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceInterfaceLayout_second_get", _wrap_pairstringTDeviceInterfaceLayout_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceInterfaceLayout", _wrap_delete_pairstringTDeviceInterfaceLayout, METH_O, NULL},
	 { "pairstringTDeviceInterfaceLayout_swigregister", pairstringTDeviceInterfaceLayout_swigregister, METH_O, NULL},
	 { "pairstringTDeviceInterfaceLayout_swiginit", pairstringTDeviceInterfaceLayout_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceLoadSettings", _wrap_new_PropertyIDeviceLoadSettings, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceLoadSettings_getTranslationDict", _wrap_PropertyIDeviceLoadSettings_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceLoadSettings_getTranslationDictString", _wrap_PropertyIDeviceLoadSettings_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceLoadSettings_getTranslationDictValue", _wrap_PropertyIDeviceLoadSettings_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceLoadSettings_getTranslationDictStrings", _wrap_PropertyIDeviceLoadSettings_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceLoadSettings_getTranslationDictValues", _wrap_PropertyIDeviceLoadSettings_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceLoadSettings_getMaxValue", _wrap_PropertyIDeviceLoadSettings_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceLoadSettings_getMinValue", _wrap_PropertyIDeviceLoadSettings_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceLoadSettings_getStepWidth", _wrap_PropertyIDeviceLoadSettings_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceLoadSettings_read", _wrap_PropertyIDeviceLoadSettings_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceLoadSettings_write", _wrap_PropertyIDeviceLoadSettings_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceLoadSettings", _wrap_delete_PropertyIDeviceLoadSettings, METH_O, NULL},
	 { "PropertyIDeviceLoadSettings_swigregister", PropertyIDeviceLoadSettings_swigregister, METH_O, NULL},
	 { "PropertyIDeviceLoadSettings_swiginit", PropertyIDeviceLoadSettings_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceLoadSettings", _wrap_new_pairstringTDeviceLoadSettings, METH_VARARGS, NULL},
	 { "pairstringTDeviceLoadSettings_first_set", _wrap_pairstringTDeviceLoadSettings_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceLoadSettings_first_get", _wrap_pairstringTDeviceLoadSettings_first_get, METH_O, NULL},
	 { "pairstringTDeviceLoadSettings_second_set", _wrap_pairstringTDeviceLoadSettings_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceLoadSettings_second_get", _wrap_pairstringTDeviceLoadSettings_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceLoadSettings", _wrap_delete_pairstringTDeviceLoadSettings, METH_O, NULL},
	 { "pairstringTDeviceLoadSettings_swigregister", pairstringTDeviceLoadSettings_swigregister, METH_O, NULL},
	 { "pairstringTDeviceLoadSettings_swiginit", pairstringTDeviceLoadSettings_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDevicePowerMode", _wrap_new_PropertyIDevicePowerMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDevicePowerMode_getTranslationDict", _wrap_PropertyIDevicePowerMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDevicePowerMode_getTranslationDictString", _wrap_PropertyIDevicePowerMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDevicePowerMode_getTranslationDictValue", _wrap_PropertyIDevicePowerMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDevicePowerMode_getTranslationDictStrings", _wrap_PropertyIDevicePowerMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDevicePowerMode_getTranslationDictValues", _wrap_PropertyIDevicePowerMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDevicePowerMode_getMaxValue", _wrap_PropertyIDevicePowerMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDevicePowerMode_getMinValue", _wrap_PropertyIDevicePowerMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDevicePowerMode_getStepWidth", _wrap_PropertyIDevicePowerMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDevicePowerMode_read", _wrap_PropertyIDevicePowerMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDevicePowerMode_write", _wrap_PropertyIDevicePowerMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDevicePowerMode", _wrap_delete_PropertyIDevicePowerMode, METH_O, NULL},
	 { "PropertyIDevicePowerMode_swigregister", PropertyIDevicePowerMode_swigregister, METH_O, NULL},
	 { "PropertyIDevicePowerMode_swiginit", PropertyIDevicePowerMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDevicePowerMode", _wrap_new_pairstringTDevicePowerMode, METH_VARARGS, NULL},
	 { "pairstringTDevicePowerMode_first_set", _wrap_pairstringTDevicePowerMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDevicePowerMode_first_get", _wrap_pairstringTDevicePowerMode_first_get, METH_O, NULL},
	 { "pairstringTDevicePowerMode_second_set", _wrap_pairstringTDevicePowerMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDevicePowerMode_second_get", _wrap_pairstringTDevicePowerMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDevicePowerMode", _wrap_delete_pairstringTDevicePowerMode, METH_O, NULL},
	 { "pairstringTDevicePowerMode_swigregister", pairstringTDevicePowerMode_swigregister, METH_O, NULL},
	 { "pairstringTDevicePowerMode_swiginit", pairstringTDevicePowerMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceScanRateMode", _wrap_new_PropertyIDeviceScanRateMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceScanRateMode_getTranslationDict", _wrap_PropertyIDeviceScanRateMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceScanRateMode_getTranslationDictString", _wrap_PropertyIDeviceScanRateMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceScanRateMode_getTranslationDictValue", _wrap_PropertyIDeviceScanRateMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceScanRateMode_getTranslationDictStrings", _wrap_PropertyIDeviceScanRateMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceScanRateMode_getTranslationDictValues", _wrap_PropertyIDeviceScanRateMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceScanRateMode_getMaxValue", _wrap_PropertyIDeviceScanRateMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceScanRateMode_getMinValue", _wrap_PropertyIDeviceScanRateMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceScanRateMode_getStepWidth", _wrap_PropertyIDeviceScanRateMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceScanRateMode_read", _wrap_PropertyIDeviceScanRateMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceScanRateMode_write", _wrap_PropertyIDeviceScanRateMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceScanRateMode", _wrap_delete_PropertyIDeviceScanRateMode, METH_O, NULL},
	 { "PropertyIDeviceScanRateMode_swigregister", PropertyIDeviceScanRateMode_swigregister, METH_O, NULL},
	 { "PropertyIDeviceScanRateMode_swiginit", PropertyIDeviceScanRateMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceScanRateMode", _wrap_new_pairstringTDeviceScanRateMode, METH_VARARGS, NULL},
	 { "pairstringTDeviceScanRateMode_first_set", _wrap_pairstringTDeviceScanRateMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceScanRateMode_first_get", _wrap_pairstringTDeviceScanRateMode_first_get, METH_O, NULL},
	 { "pairstringTDeviceScanRateMode_second_set", _wrap_pairstringTDeviceScanRateMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceScanRateMode_second_get", _wrap_pairstringTDeviceScanRateMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceScanRateMode", _wrap_delete_pairstringTDeviceScanRateMode, METH_O, NULL},
	 { "pairstringTDeviceScanRateMode_swigregister", pairstringTDeviceScanRateMode_swigregister, METH_O, NULL},
	 { "pairstringTDeviceScanRateMode_swiginit", pairstringTDeviceScanRateMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceSignalOutputStartEvent", _wrap_new_PropertyIDeviceSignalOutputStartEvent, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_getTranslationDict", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_getTranslationDictString", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_getTranslationDictValues", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_getMaxValue", _wrap_PropertyIDeviceSignalOutputStartEvent_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_getMinValue", _wrap_PropertyIDeviceSignalOutputStartEvent_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_getStepWidth", _wrap_PropertyIDeviceSignalOutputStartEvent_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_read", _wrap_PropertyIDeviceSignalOutputStartEvent_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceSignalOutputStartEvent_write", _wrap_PropertyIDeviceSignalOutputStartEvent_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceSignalOutputStartEvent", _wrap_delete_PropertyIDeviceSignalOutputStartEvent, METH_O, NULL},
	 { "PropertyIDeviceSignalOutputStartEvent_swigregister", PropertyIDeviceSignalOutputStartEvent_swigregister, METH_O, NULL},
	 { "PropertyIDeviceSignalOutputStartEvent_swiginit", PropertyIDeviceSignalOutputStartEvent_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceSignalOutputStartEvent", _wrap_new_pairstringTDeviceSignalOutputStartEvent, METH_VARARGS, NULL},
	 { "pairstringTDeviceSignalOutputStartEvent_first_set", _wrap_pairstringTDeviceSignalOutputStartEvent_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceSignalOutputStartEvent_first_get", _wrap_pairstringTDeviceSignalOutputStartEvent_first_get, METH_O, NULL},
	 { "pairstringTDeviceSignalOutputStartEvent_second_set", _wrap_pairstringTDeviceSignalOutputStartEvent_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceSignalOutputStartEvent_second_get", _wrap_pairstringTDeviceSignalOutputStartEvent_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceSignalOutputStartEvent", _wrap_delete_pairstringTDeviceSignalOutputStartEvent, METH_O, NULL},
	 { "pairstringTDeviceSignalOutputStartEvent_swigregister", pairstringTDeviceSignalOutputStartEvent_swigregister, METH_O, NULL},
	 { "pairstringTDeviceSignalOutputStartEvent_swiginit", pairstringTDeviceSignalOutputStartEvent_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceState", _wrap_new_PropertyIDeviceState, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceState_getTranslationDict", _wrap_PropertyIDeviceState_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceState >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceState > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceState_getTranslationDictString", _wrap_PropertyIDeviceState_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceState_getTranslationDictValue", _wrap_PropertyIDeviceState_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceState_getTranslationDictStrings", _wrap_PropertyIDeviceState_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceState_getTranslationDictValues", _wrap_PropertyIDeviceState_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceState_getMaxValue", _wrap_PropertyIDeviceState_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceState_getMinValue", _wrap_PropertyIDeviceState_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceState_getStepWidth", _wrap_PropertyIDeviceState_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceState_read", _wrap_PropertyIDeviceState_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceState_write", _wrap_PropertyIDeviceState_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceState", _wrap_delete_PropertyIDeviceState, METH_O, NULL},
	 { "PropertyIDeviceState_swigregister", PropertyIDeviceState_swigregister, METH_O, NULL},
	 { "PropertyIDeviceState_swiginit", PropertyIDeviceState_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceState", _wrap_new_pairstringTDeviceState, METH_VARARGS, NULL},
	 { "pairstringTDeviceState_first_set", _wrap_pairstringTDeviceState_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceState_first_get", _wrap_pairstringTDeviceState_first_get, METH_O, NULL},
	 { "pairstringTDeviceState_second_set", _wrap_pairstringTDeviceState_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceState_second_get", _wrap_pairstringTDeviceState_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceState", _wrap_delete_pairstringTDeviceState, METH_O, NULL},
	 { "pairstringTDeviceState_swigregister", pairstringTDeviceState_swigregister, METH_O, NULL},
	 { "pairstringTDeviceState_swiginit", pairstringTDeviceState_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceSyncOutMode", _wrap_new_PropertyIDeviceSyncOutMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceSyncOutMode_getTranslationDict", _wrap_PropertyIDeviceSyncOutMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceSyncOutMode_getTranslationDictString", _wrap_PropertyIDeviceSyncOutMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceSyncOutMode_getTranslationDictValue", _wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceSyncOutMode_getTranslationDictStrings", _wrap_PropertyIDeviceSyncOutMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceSyncOutMode_getTranslationDictValues", _wrap_PropertyIDeviceSyncOutMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceSyncOutMode_getMaxValue", _wrap_PropertyIDeviceSyncOutMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceSyncOutMode_getMinValue", _wrap_PropertyIDeviceSyncOutMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceSyncOutMode_getStepWidth", _wrap_PropertyIDeviceSyncOutMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceSyncOutMode_read", _wrap_PropertyIDeviceSyncOutMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceSyncOutMode_write", _wrap_PropertyIDeviceSyncOutMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceSyncOutMode", _wrap_delete_PropertyIDeviceSyncOutMode, METH_O, NULL},
	 { "PropertyIDeviceSyncOutMode_swigregister", PropertyIDeviceSyncOutMode_swigregister, METH_O, NULL},
	 { "PropertyIDeviceSyncOutMode_swiginit", PropertyIDeviceSyncOutMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceSyncOutMode", _wrap_new_pairstringTDeviceSyncOutMode, METH_VARARGS, NULL},
	 { "pairstringTDeviceSyncOutMode_first_set", _wrap_pairstringTDeviceSyncOutMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceSyncOutMode_first_get", _wrap_pairstringTDeviceSyncOutMode_first_get, METH_O, NULL},
	 { "pairstringTDeviceSyncOutMode_second_set", _wrap_pairstringTDeviceSyncOutMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceSyncOutMode_second_get", _wrap_pairstringTDeviceSyncOutMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceSyncOutMode", _wrap_delete_pairstringTDeviceSyncOutMode, METH_O, NULL},
	 { "pairstringTDeviceSyncOutMode_swigregister", pairstringTDeviceSyncOutMode_swigregister, METH_O, NULL},
	 { "pairstringTDeviceSyncOutMode_swiginit", pairstringTDeviceSyncOutMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceTriggerInterface", _wrap_new_PropertyIDeviceTriggerInterface, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceTriggerInterface_getTranslationDict", _wrap_PropertyIDeviceTriggerInterface_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceTriggerInterface_getTranslationDictString", _wrap_PropertyIDeviceTriggerInterface_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceTriggerInterface_getTranslationDictValue", _wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceTriggerInterface_getTranslationDictStrings", _wrap_PropertyIDeviceTriggerInterface_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceTriggerInterface_getTranslationDictValues", _wrap_PropertyIDeviceTriggerInterface_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceTriggerInterface_getMaxValue", _wrap_PropertyIDeviceTriggerInterface_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceTriggerInterface_getMinValue", _wrap_PropertyIDeviceTriggerInterface_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceTriggerInterface_getStepWidth", _wrap_PropertyIDeviceTriggerInterface_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceTriggerInterface_read", _wrap_PropertyIDeviceTriggerInterface_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceTriggerInterface_write", _wrap_PropertyIDeviceTriggerInterface_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceTriggerInterface", _wrap_delete_PropertyIDeviceTriggerInterface, METH_O, NULL},
	 { "PropertyIDeviceTriggerInterface_swigregister", PropertyIDeviceTriggerInterface_swigregister, METH_O, NULL},
	 { "PropertyIDeviceTriggerInterface_swiginit", PropertyIDeviceTriggerInterface_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceTriggerInterface", _wrap_new_pairstringTDeviceTriggerInterface, METH_VARARGS, NULL},
	 { "pairstringTDeviceTriggerInterface_first_set", _wrap_pairstringTDeviceTriggerInterface_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceTriggerInterface_first_get", _wrap_pairstringTDeviceTriggerInterface_first_get, METH_O, NULL},
	 { "pairstringTDeviceTriggerInterface_second_set", _wrap_pairstringTDeviceTriggerInterface_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceTriggerInterface_second_get", _wrap_pairstringTDeviceTriggerInterface_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceTriggerInterface", _wrap_delete_pairstringTDeviceTriggerInterface, METH_O, NULL},
	 { "pairstringTDeviceTriggerInterface_swigregister", pairstringTDeviceTriggerInterface_swigregister, METH_O, NULL},
	 { "pairstringTDeviceTriggerInterface_swiginit", pairstringTDeviceTriggerInterface_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDeviceTriggerMode", _wrap_new_PropertyIDeviceTriggerMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDeviceTriggerMode_getTranslationDict", _wrap_PropertyIDeviceTriggerMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDeviceTriggerMode_getTranslationDictString", _wrap_PropertyIDeviceTriggerMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceTriggerMode_getTranslationDictValue", _wrap_PropertyIDeviceTriggerMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDeviceTriggerMode_getTranslationDictStrings", _wrap_PropertyIDeviceTriggerMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceTriggerMode_getTranslationDictValues", _wrap_PropertyIDeviceTriggerMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDeviceTriggerMode_getMaxValue", _wrap_PropertyIDeviceTriggerMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceTriggerMode_getMinValue", _wrap_PropertyIDeviceTriggerMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceTriggerMode_getStepWidth", _wrap_PropertyIDeviceTriggerMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDeviceTriggerMode_read", _wrap_PropertyIDeviceTriggerMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDeviceTriggerMode_write", _wrap_PropertyIDeviceTriggerMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDeviceTriggerMode", _wrap_delete_PropertyIDeviceTriggerMode, METH_O, NULL},
	 { "PropertyIDeviceTriggerMode_swigregister", PropertyIDeviceTriggerMode_swigregister, METH_O, NULL},
	 { "PropertyIDeviceTriggerMode_swiginit", PropertyIDeviceTriggerMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceTriggerMode", _wrap_new_pairstringTDeviceTriggerMode, METH_VARARGS, NULL},
	 { "pairstringTDeviceTriggerMode_first_set", _wrap_pairstringTDeviceTriggerMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceTriggerMode_first_get", _wrap_pairstringTDeviceTriggerMode_first_get, METH_O, NULL},
	 { "pairstringTDeviceTriggerMode_second_set", _wrap_pairstringTDeviceTriggerMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceTriggerMode_second_get", _wrap_pairstringTDeviceTriggerMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceTriggerMode", _wrap_delete_pairstringTDeviceTriggerMode, METH_O, NULL},
	 { "pairstringTDeviceTriggerMode_swigregister", pairstringTDeviceTriggerMode_swigregister, METH_O, NULL},
	 { "pairstringTDeviceTriggerMode_swiginit", pairstringTDeviceTriggerMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDigIOState", _wrap_new_PropertyIDigIOState, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDigIOState_getTranslationDict", _wrap_PropertyIDigIOState_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigIOState >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigIOState > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDigIOState_getTranslationDictString", _wrap_PropertyIDigIOState_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigIOState_getTranslationDictValue", _wrap_PropertyIDigIOState_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigIOState_getTranslationDictStrings", _wrap_PropertyIDigIOState_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigIOState_getTranslationDictValues", _wrap_PropertyIDigIOState_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigIOState_getMaxValue", _wrap_PropertyIDigIOState_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigIOState_getMinValue", _wrap_PropertyIDigIOState_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigIOState_getStepWidth", _wrap_PropertyIDigIOState_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigIOState_read", _wrap_PropertyIDigIOState_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDigIOState_write", _wrap_PropertyIDigIOState_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDigIOState", _wrap_delete_PropertyIDigIOState, METH_O, NULL},
	 { "PropertyIDigIOState_swigregister", PropertyIDigIOState_swigregister, METH_O, NULL},
	 { "PropertyIDigIOState_swiginit", PropertyIDigIOState_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDigIOState", _wrap_new_pairstringTDigIOState, METH_VARARGS, NULL},
	 { "pairstringTDigIOState_first_set", _wrap_pairstringTDigIOState_first_set, METH_VARARGS, NULL},
	 { "pairstringTDigIOState_first_get", _wrap_pairstringTDigIOState_first_get, METH_O, NULL},
	 { "pairstringTDigIOState_second_set", _wrap_pairstringTDigIOState_second_set, METH_VARARGS, NULL},
	 { "pairstringTDigIOState_second_get", _wrap_pairstringTDigIOState_second_get, METH_O, NULL},
	 { "delete_pairstringTDigIOState", _wrap_delete_pairstringTDigIOState, METH_O, NULL},
	 { "pairstringTDigIOState_swigregister", pairstringTDigIOState_swigregister, METH_O, NULL},
	 { "pairstringTDigIOState_swiginit", pairstringTDigIOState_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDigitalIOMeasurementMode", _wrap_new_PropertyIDigitalIOMeasurementMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_getTranslationDict", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_getTranslationDictString", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_getTranslationDictValue", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_getTranslationDictStrings", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_getTranslationDictValues", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_getMaxValue", _wrap_PropertyIDigitalIOMeasurementMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_getMinValue", _wrap_PropertyIDigitalIOMeasurementMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_getStepWidth", _wrap_PropertyIDigitalIOMeasurementMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_read", _wrap_PropertyIDigitalIOMeasurementMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDigitalIOMeasurementMode_write", _wrap_PropertyIDigitalIOMeasurementMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDigitalIOMeasurementMode", _wrap_delete_PropertyIDigitalIOMeasurementMode, METH_O, NULL},
	 { "PropertyIDigitalIOMeasurementMode_swigregister", PropertyIDigitalIOMeasurementMode_swigregister, METH_O, NULL},
	 { "PropertyIDigitalIOMeasurementMode_swiginit", PropertyIDigitalIOMeasurementMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDigitalIOMeasurementMode", _wrap_new_pairstringTDigitalIOMeasurementMode, METH_VARARGS, NULL},
	 { "pairstringTDigitalIOMeasurementMode_first_set", _wrap_pairstringTDigitalIOMeasurementMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDigitalIOMeasurementMode_first_get", _wrap_pairstringTDigitalIOMeasurementMode_first_get, METH_O, NULL},
	 { "pairstringTDigitalIOMeasurementMode_second_set", _wrap_pairstringTDigitalIOMeasurementMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDigitalIOMeasurementMode_second_get", _wrap_pairstringTDigitalIOMeasurementMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDigitalIOMeasurementMode", _wrap_delete_pairstringTDigitalIOMeasurementMode, METH_O, NULL},
	 { "pairstringTDigitalIOMeasurementMode_swigregister", pairstringTDigitalIOMeasurementMode_swigregister, METH_O, NULL},
	 { "pairstringTDigitalIOMeasurementMode_swiginit", pairstringTDigitalIOMeasurementMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDigitalIOMeasurementSource", _wrap_new_PropertyIDigitalIOMeasurementSource, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_getTranslationDict", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_getTranslationDictString", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_getTranslationDictValue", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_getTranslationDictStrings", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_getTranslationDictValues", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_getMaxValue", _wrap_PropertyIDigitalIOMeasurementSource_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_getMinValue", _wrap_PropertyIDigitalIOMeasurementSource_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_getStepWidth", _wrap_PropertyIDigitalIOMeasurementSource_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_read", _wrap_PropertyIDigitalIOMeasurementSource_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDigitalIOMeasurementSource_write", _wrap_PropertyIDigitalIOMeasurementSource_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDigitalIOMeasurementSource", _wrap_delete_PropertyIDigitalIOMeasurementSource, METH_O, NULL},
	 { "PropertyIDigitalIOMeasurementSource_swigregister", PropertyIDigitalIOMeasurementSource_swigregister, METH_O, NULL},
	 { "PropertyIDigitalIOMeasurementSource_swiginit", PropertyIDigitalIOMeasurementSource_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDigitalIOMeasurementSource", _wrap_new_pairstringTDigitalIOMeasurementSource, METH_VARARGS, NULL},
	 { "pairstringTDigitalIOMeasurementSource_first_set", _wrap_pairstringTDigitalIOMeasurementSource_first_set, METH_VARARGS, NULL},
	 { "pairstringTDigitalIOMeasurementSource_first_get", _wrap_pairstringTDigitalIOMeasurementSource_first_get, METH_O, NULL},
	 { "pairstringTDigitalIOMeasurementSource_second_set", _wrap_pairstringTDigitalIOMeasurementSource_second_set, METH_VARARGS, NULL},
	 { "pairstringTDigitalIOMeasurementSource_second_get", _wrap_pairstringTDigitalIOMeasurementSource_second_get, METH_O, NULL},
	 { "delete_pairstringTDigitalIOMeasurementSource", _wrap_delete_pairstringTDigitalIOMeasurementSource, METH_O, NULL},
	 { "pairstringTDigitalIOMeasurementSource_swigregister", pairstringTDigitalIOMeasurementSource_swigregister, METH_O, NULL},
	 { "pairstringTDigitalIOMeasurementSource_swiginit", pairstringTDigitalIOMeasurementSource_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDigitalOutputControlMode", _wrap_new_PropertyIDigitalOutputControlMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDigitalOutputControlMode_getTranslationDict", _wrap_PropertyIDigitalOutputControlMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDigitalOutputControlMode_getTranslationDictString", _wrap_PropertyIDigitalOutputControlMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigitalOutputControlMode_getTranslationDictValue", _wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigitalOutputControlMode_getTranslationDictStrings", _wrap_PropertyIDigitalOutputControlMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigitalOutputControlMode_getTranslationDictValues", _wrap_PropertyIDigitalOutputControlMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigitalOutputControlMode_getMaxValue", _wrap_PropertyIDigitalOutputControlMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalOutputControlMode_getMinValue", _wrap_PropertyIDigitalOutputControlMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalOutputControlMode_getStepWidth", _wrap_PropertyIDigitalOutputControlMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalOutputControlMode_read", _wrap_PropertyIDigitalOutputControlMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDigitalOutputControlMode_write", _wrap_PropertyIDigitalOutputControlMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDigitalOutputControlMode", _wrap_delete_PropertyIDigitalOutputControlMode, METH_O, NULL},
	 { "PropertyIDigitalOutputControlMode_swigregister", PropertyIDigitalOutputControlMode_swigregister, METH_O, NULL},
	 { "PropertyIDigitalOutputControlMode_swiginit", PropertyIDigitalOutputControlMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDigitalOutputControlMode", _wrap_new_pairstringTDigitalOutputControlMode, METH_VARARGS, NULL},
	 { "pairstringTDigitalOutputControlMode_first_set", _wrap_pairstringTDigitalOutputControlMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTDigitalOutputControlMode_first_get", _wrap_pairstringTDigitalOutputControlMode_first_get, METH_O, NULL},
	 { "pairstringTDigitalOutputControlMode_second_set", _wrap_pairstringTDigitalOutputControlMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTDigitalOutputControlMode_second_get", _wrap_pairstringTDigitalOutputControlMode_second_get, METH_O, NULL},
	 { "delete_pairstringTDigitalOutputControlMode", _wrap_delete_pairstringTDigitalOutputControlMode, METH_O, NULL},
	 { "pairstringTDigitalOutputControlMode_swigregister", pairstringTDigitalOutputControlMode_swigregister, METH_O, NULL},
	 { "pairstringTDigitalOutputControlMode_swiginit", pairstringTDigitalOutputControlMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIDigitalSignal", _wrap_new_PropertyIDigitalSignal, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIDigitalSignal_getTranslationDict", _wrap_PropertyIDigitalSignal_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIDigitalSignal_getTranslationDictString", _wrap_PropertyIDigitalSignal_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigitalSignal_getTranslationDictValue", _wrap_PropertyIDigitalSignal_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIDigitalSignal_getTranslationDictStrings", _wrap_PropertyIDigitalSignal_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigitalSignal_getTranslationDictValues", _wrap_PropertyIDigitalSignal_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIDigitalSignal_getMaxValue", _wrap_PropertyIDigitalSignal_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalSignal_getMinValue", _wrap_PropertyIDigitalSignal_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalSignal_getStepWidth", _wrap_PropertyIDigitalSignal_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIDigitalSignal_read", _wrap_PropertyIDigitalSignal_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIDigitalSignal_write", _wrap_PropertyIDigitalSignal_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIDigitalSignal", _wrap_delete_PropertyIDigitalSignal, METH_O, NULL},
	 { "PropertyIDigitalSignal_swigregister", PropertyIDigitalSignal_swigregister, METH_O, NULL},
	 { "PropertyIDigitalSignal_swiginit", PropertyIDigitalSignal_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDigitalSignal", _wrap_new_pairstringTDigitalSignal, METH_VARARGS, NULL},
	 { "pairstringTDigitalSignal_first_set", _wrap_pairstringTDigitalSignal_first_set, METH_VARARGS, NULL},
	 { "pairstringTDigitalSignal_first_get", _wrap_pairstringTDigitalSignal_first_get, METH_O, NULL},
	 { "pairstringTDigitalSignal_second_set", _wrap_pairstringTDigitalSignal_second_set, METH_VARARGS, NULL},
	 { "pairstringTDigitalSignal_second_get", _wrap_pairstringTDigitalSignal_second_get, METH_O, NULL},
	 { "delete_pairstringTDigitalSignal", _wrap_delete_pairstringTDigitalSignal, METH_O, NULL},
	 { "pairstringTDigitalSignal_swigregister", pairstringTDigitalSignal_swigregister, METH_O, NULL},
	 { "pairstringTDigitalSignal_swiginit", pairstringTDigitalSignal_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIFieldGateMode", _wrap_new_PropertyIFieldGateMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIFieldGateMode_getTranslationDict", _wrap_PropertyIFieldGateMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIFieldGateMode_getTranslationDictString", _wrap_PropertyIFieldGateMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIFieldGateMode_getTranslationDictValue", _wrap_PropertyIFieldGateMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIFieldGateMode_getTranslationDictStrings", _wrap_PropertyIFieldGateMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIFieldGateMode_getTranslationDictValues", _wrap_PropertyIFieldGateMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIFieldGateMode_getMaxValue", _wrap_PropertyIFieldGateMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIFieldGateMode_getMinValue", _wrap_PropertyIFieldGateMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIFieldGateMode_getStepWidth", _wrap_PropertyIFieldGateMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIFieldGateMode_read", _wrap_PropertyIFieldGateMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIFieldGateMode_write", _wrap_PropertyIFieldGateMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIFieldGateMode", _wrap_delete_PropertyIFieldGateMode, METH_O, NULL},
	 { "PropertyIFieldGateMode_swigregister", PropertyIFieldGateMode_swigregister, METH_O, NULL},
	 { "PropertyIFieldGateMode_swiginit", PropertyIFieldGateMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTFieldGateMode", _wrap_new_pairstringTFieldGateMode, METH_VARARGS, NULL},
	 { "pairstringTFieldGateMode_first_set", _wrap_pairstringTFieldGateMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTFieldGateMode_first_get", _wrap_pairstringTFieldGateMode_first_get, METH_O, NULL},
	 { "pairstringTFieldGateMode_second_set", _wrap_pairstringTFieldGateMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTFieldGateMode_second_get", _wrap_pairstringTFieldGateMode_second_get, METH_O, NULL},
	 { "delete_pairstringTFieldGateMode", _wrap_delete_pairstringTFieldGateMode, METH_O, NULL},
	 { "pairstringTFieldGateMode_swigregister", pairstringTFieldGateMode_swigregister, METH_O, NULL},
	 { "pairstringTFieldGateMode_swiginit", pairstringTFieldGateMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIFlatFieldFilterCorrectionMode", _wrap_new_PropertyIFlatFieldFilterCorrectionMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_getTranslationDict", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValues", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_getMaxValue", _wrap_PropertyIFlatFieldFilterCorrectionMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_getMinValue", _wrap_PropertyIFlatFieldFilterCorrectionMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_getStepWidth", _wrap_PropertyIFlatFieldFilterCorrectionMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_read", _wrap_PropertyIFlatFieldFilterCorrectionMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIFlatFieldFilterCorrectionMode_write", _wrap_PropertyIFlatFieldFilterCorrectionMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIFlatFieldFilterCorrectionMode", _wrap_delete_PropertyIFlatFieldFilterCorrectionMode, METH_O, NULL},
	 { "PropertyIFlatFieldFilterCorrectionMode_swigregister", PropertyIFlatFieldFilterCorrectionMode_swigregister, METH_O, NULL},
	 { "PropertyIFlatFieldFilterCorrectionMode_swiginit", PropertyIFlatFieldFilterCorrectionMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTFlatFieldFilterCorrectionMode", _wrap_new_pairstringTFlatFieldFilterCorrectionMode, METH_VARARGS, NULL},
	 { "pairstringTFlatFieldFilterCorrectionMode_first_set", _wrap_pairstringTFlatFieldFilterCorrectionMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTFlatFieldFilterCorrectionMode_first_get", _wrap_pairstringTFlatFieldFilterCorrectionMode_first_get, METH_O, NULL},
	 { "pairstringTFlatFieldFilterCorrectionMode_second_set", _wrap_pairstringTFlatFieldFilterCorrectionMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTFlatFieldFilterCorrectionMode_second_get", _wrap_pairstringTFlatFieldFilterCorrectionMode_second_get, METH_O, NULL},
	 { "delete_pairstringTFlatFieldFilterCorrectionMode", _wrap_delete_pairstringTFlatFieldFilterCorrectionMode, METH_O, NULL},
	 { "pairstringTFlatFieldFilterCorrectionMode_swigregister", pairstringTFlatFieldFilterCorrectionMode_swigregister, METH_O, NULL},
	 { "pairstringTFlatFieldFilterCorrectionMode_swiginit", pairstringTFlatFieldFilterCorrectionMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIFlatFieldFilterMode", _wrap_new_PropertyIFlatFieldFilterMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIFlatFieldFilterMode_getTranslationDict", _wrap_PropertyIFlatFieldFilterMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIFlatFieldFilterMode_getTranslationDictString", _wrap_PropertyIFlatFieldFilterMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIFlatFieldFilterMode_getTranslationDictValue", _wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIFlatFieldFilterMode_getTranslationDictStrings", _wrap_PropertyIFlatFieldFilterMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIFlatFieldFilterMode_getTranslationDictValues", _wrap_PropertyIFlatFieldFilterMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIFlatFieldFilterMode_getMaxValue", _wrap_PropertyIFlatFieldFilterMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIFlatFieldFilterMode_getMinValue", _wrap_PropertyIFlatFieldFilterMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIFlatFieldFilterMode_getStepWidth", _wrap_PropertyIFlatFieldFilterMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIFlatFieldFilterMode_read", _wrap_PropertyIFlatFieldFilterMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIFlatFieldFilterMode_write", _wrap_PropertyIFlatFieldFilterMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIFlatFieldFilterMode", _wrap_delete_PropertyIFlatFieldFilterMode, METH_O, NULL},
	 { "PropertyIFlatFieldFilterMode_swigregister", PropertyIFlatFieldFilterMode_swigregister, METH_O, NULL},
	 { "PropertyIFlatFieldFilterMode_swiginit", PropertyIFlatFieldFilterMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTFlatFieldFilterMode", _wrap_new_pairstringTFlatFieldFilterMode, METH_VARARGS, NULL},
	 { "pairstringTFlatFieldFilterMode_first_set", _wrap_pairstringTFlatFieldFilterMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTFlatFieldFilterMode_first_get", _wrap_pairstringTFlatFieldFilterMode_first_get, METH_O, NULL},
	 { "pairstringTFlatFieldFilterMode_second_set", _wrap_pairstringTFlatFieldFilterMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTFlatFieldFilterMode_second_get", _wrap_pairstringTFlatFieldFilterMode_second_get, METH_O, NULL},
	 { "delete_pairstringTFlatFieldFilterMode", _wrap_delete_pairstringTFlatFieldFilterMode, METH_O, NULL},
	 { "pairstringTFlatFieldFilterMode_swigregister", pairstringTFlatFieldFilterMode_swigregister, METH_O, NULL},
	 { "pairstringTFlatFieldFilterMode_swiginit", pairstringTFlatFieldFilterMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIHWUpdateResult", _wrap_new_PropertyIHWUpdateResult, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIHWUpdateResult_getTranslationDict", _wrap_PropertyIHWUpdateResult_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIHWUpdateResult_getTranslationDictString", _wrap_PropertyIHWUpdateResult_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIHWUpdateResult_getTranslationDictValue", _wrap_PropertyIHWUpdateResult_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIHWUpdateResult_getTranslationDictStrings", _wrap_PropertyIHWUpdateResult_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIHWUpdateResult_getTranslationDictValues", _wrap_PropertyIHWUpdateResult_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIHWUpdateResult_getMaxValue", _wrap_PropertyIHWUpdateResult_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIHWUpdateResult_getMinValue", _wrap_PropertyIHWUpdateResult_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIHWUpdateResult_getStepWidth", _wrap_PropertyIHWUpdateResult_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIHWUpdateResult_read", _wrap_PropertyIHWUpdateResult_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIHWUpdateResult_write", _wrap_PropertyIHWUpdateResult_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIHWUpdateResult", _wrap_delete_PropertyIHWUpdateResult, METH_O, NULL},
	 { "PropertyIHWUpdateResult_swigregister", PropertyIHWUpdateResult_swigregister, METH_O, NULL},
	 { "PropertyIHWUpdateResult_swiginit", PropertyIHWUpdateResult_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTHWUpdateResult", _wrap_new_pairstringTHWUpdateResult, METH_VARARGS, NULL},
	 { "pairstringTHWUpdateResult_first_set", _wrap_pairstringTHWUpdateResult_first_set, METH_VARARGS, NULL},
	 { "pairstringTHWUpdateResult_first_get", _wrap_pairstringTHWUpdateResult_first_get, METH_O, NULL},
	 { "pairstringTHWUpdateResult_second_set", _wrap_pairstringTHWUpdateResult_second_set, METH_VARARGS, NULL},
	 { "pairstringTHWUpdateResult_second_get", _wrap_pairstringTHWUpdateResult_second_get, METH_O, NULL},
	 { "delete_pairstringTHWUpdateResult", _wrap_delete_pairstringTHWUpdateResult, METH_O, NULL},
	 { "pairstringTHWUpdateResult_swigregister", pairstringTHWUpdateResult_swigregister, METH_O, NULL},
	 { "pairstringTHWUpdateResult_swiginit", pairstringTHWUpdateResult_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyII2COperationMode", _wrap_new_PropertyII2COperationMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyII2COperationMode_getTranslationDict", _wrap_PropertyII2COperationMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyII2COperationMode_getTranslationDictString", _wrap_PropertyII2COperationMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyII2COperationMode_getTranslationDictValue", _wrap_PropertyII2COperationMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyII2COperationMode_getTranslationDictStrings", _wrap_PropertyII2COperationMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyII2COperationMode_getTranslationDictValues", _wrap_PropertyII2COperationMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyII2COperationMode_getMaxValue", _wrap_PropertyII2COperationMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyII2COperationMode_getMinValue", _wrap_PropertyII2COperationMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyII2COperationMode_getStepWidth", _wrap_PropertyII2COperationMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyII2COperationMode_read", _wrap_PropertyII2COperationMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyII2COperationMode_write", _wrap_PropertyII2COperationMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyII2COperationMode", _wrap_delete_PropertyII2COperationMode, METH_O, NULL},
	 { "PropertyII2COperationMode_swigregister", PropertyII2COperationMode_swigregister, METH_O, NULL},
	 { "PropertyII2COperationMode_swiginit", PropertyII2COperationMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTI2COperationMode", _wrap_new_pairstringTI2COperationMode, METH_VARARGS, NULL},
	 { "pairstringTI2COperationMode_first_set", _wrap_pairstringTI2COperationMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTI2COperationMode_first_get", _wrap_pairstringTI2COperationMode_first_get, METH_O, NULL},
	 { "pairstringTI2COperationMode_second_set", _wrap_pairstringTI2COperationMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTI2COperationMode_second_get", _wrap_pairstringTI2COperationMode_second_get, METH_O, NULL},
	 { "delete_pairstringTI2COperationMode", _wrap_delete_pairstringTI2COperationMode, METH_O, NULL},
	 { "pairstringTI2COperationMode_swigregister", pairstringTI2COperationMode_swigregister, METH_O, NULL},
	 { "pairstringTI2COperationMode_swiginit", pairstringTI2COperationMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyII2COperationStatus", _wrap_new_PropertyII2COperationStatus, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyII2COperationStatus_getTranslationDict", _wrap_PropertyII2COperationStatus_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyII2COperationStatus_getTranslationDictString", _wrap_PropertyII2COperationStatus_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyII2COperationStatus_getTranslationDictValue", _wrap_PropertyII2COperationStatus_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyII2COperationStatus_getTranslationDictStrings", _wrap_PropertyII2COperationStatus_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyII2COperationStatus_getTranslationDictValues", _wrap_PropertyII2COperationStatus_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyII2COperationStatus_getMaxValue", _wrap_PropertyII2COperationStatus_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyII2COperationStatus_getMinValue", _wrap_PropertyII2COperationStatus_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyII2COperationStatus_getStepWidth", _wrap_PropertyII2COperationStatus_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyII2COperationStatus_read", _wrap_PropertyII2COperationStatus_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyII2COperationStatus_write", _wrap_PropertyII2COperationStatus_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyII2COperationStatus", _wrap_delete_PropertyII2COperationStatus, METH_O, NULL},
	 { "PropertyII2COperationStatus_swigregister", PropertyII2COperationStatus_swigregister, METH_O, NULL},
	 { "PropertyII2COperationStatus_swiginit", PropertyII2COperationStatus_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTI2COperationStatus", _wrap_new_pairstringTI2COperationStatus, METH_VARARGS, NULL},
	 { "pairstringTI2COperationStatus_first_set", _wrap_pairstringTI2COperationStatus_first_set, METH_VARARGS, NULL},
	 { "pairstringTI2COperationStatus_first_get", _wrap_pairstringTI2COperationStatus_first_get, METH_O, NULL},
	 { "pairstringTI2COperationStatus_second_set", _wrap_pairstringTI2COperationStatus_second_set, METH_VARARGS, NULL},
	 { "pairstringTI2COperationStatus_second_get", _wrap_pairstringTI2COperationStatus_second_get, METH_O, NULL},
	 { "delete_pairstringTI2COperationStatus", _wrap_delete_pairstringTI2COperationStatus, METH_O, NULL},
	 { "pairstringTI2COperationStatus_swigregister", pairstringTI2COperationStatus_swigregister, METH_O, NULL},
	 { "pairstringTI2COperationStatus_swiginit", pairstringTI2COperationStatus_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIImageBufferPixelFormat", _wrap_new_PropertyIImageBufferPixelFormat, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIImageBufferPixelFormat_getTranslationDict", _wrap_PropertyIImageBufferPixelFormat_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIImageBufferPixelFormat_getTranslationDictString", _wrap_PropertyIImageBufferPixelFormat_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageBufferPixelFormat_getTranslationDictValue", _wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageBufferPixelFormat_getTranslationDictStrings", _wrap_PropertyIImageBufferPixelFormat_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageBufferPixelFormat_getTranslationDictValues", _wrap_PropertyIImageBufferPixelFormat_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageBufferPixelFormat_getMaxValue", _wrap_PropertyIImageBufferPixelFormat_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageBufferPixelFormat_getMinValue", _wrap_PropertyIImageBufferPixelFormat_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageBufferPixelFormat_getStepWidth", _wrap_PropertyIImageBufferPixelFormat_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageBufferPixelFormat_read", _wrap_PropertyIImageBufferPixelFormat_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIImageBufferPixelFormat_write", _wrap_PropertyIImageBufferPixelFormat_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIImageBufferPixelFormat", _wrap_delete_PropertyIImageBufferPixelFormat, METH_O, NULL},
	 { "PropertyIImageBufferPixelFormat_swigregister", PropertyIImageBufferPixelFormat_swigregister, METH_O, NULL},
	 { "PropertyIImageBufferPixelFormat_swiginit", PropertyIImageBufferPixelFormat_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTImageBufferPixelFormat", _wrap_new_pairstringTImageBufferPixelFormat, METH_VARARGS, NULL},
	 { "pairstringTImageBufferPixelFormat_first_set", _wrap_pairstringTImageBufferPixelFormat_first_set, METH_VARARGS, NULL},
	 { "pairstringTImageBufferPixelFormat_first_get", _wrap_pairstringTImageBufferPixelFormat_first_get, METH_O, NULL},
	 { "pairstringTImageBufferPixelFormat_second_set", _wrap_pairstringTImageBufferPixelFormat_second_set, METH_VARARGS, NULL},
	 { "pairstringTImageBufferPixelFormat_second_get", _wrap_pairstringTImageBufferPixelFormat_second_get, METH_O, NULL},
	 { "delete_pairstringTImageBufferPixelFormat", _wrap_delete_pairstringTImageBufferPixelFormat, METH_O, NULL},
	 { "pairstringTImageBufferPixelFormat_swigregister", pairstringTImageBufferPixelFormat_swigregister, METH_O, NULL},
	 { "pairstringTImageBufferPixelFormat_swiginit", pairstringTImageBufferPixelFormat_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIImageBufferFormatReinterpreterMode", _wrap_new_PropertyIImageBufferFormatReinterpreterMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_getTranslationDict", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValues", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_getMaxValue", _wrap_PropertyIImageBufferFormatReinterpreterMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_getMinValue", _wrap_PropertyIImageBufferFormatReinterpreterMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_getStepWidth", _wrap_PropertyIImageBufferFormatReinterpreterMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_read", _wrap_PropertyIImageBufferFormatReinterpreterMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIImageBufferFormatReinterpreterMode_write", _wrap_PropertyIImageBufferFormatReinterpreterMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIImageBufferFormatReinterpreterMode", _wrap_delete_PropertyIImageBufferFormatReinterpreterMode, METH_O, NULL},
	 { "PropertyIImageBufferFormatReinterpreterMode_swigregister", PropertyIImageBufferFormatReinterpreterMode_swigregister, METH_O, NULL},
	 { "PropertyIImageBufferFormatReinterpreterMode_swiginit", PropertyIImageBufferFormatReinterpreterMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTImageBufferFormatReinterpreterMode", _wrap_new_pairstringTImageBufferFormatReinterpreterMode, METH_VARARGS, NULL},
	 { "pairstringTImageBufferFormatReinterpreterMode_first_set", _wrap_pairstringTImageBufferFormatReinterpreterMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTImageBufferFormatReinterpreterMode_first_get", _wrap_pairstringTImageBufferFormatReinterpreterMode_first_get, METH_O, NULL},
	 { "pairstringTImageBufferFormatReinterpreterMode_second_set", _wrap_pairstringTImageBufferFormatReinterpreterMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTImageBufferFormatReinterpreterMode_second_get", _wrap_pairstringTImageBufferFormatReinterpreterMode_second_get, METH_O, NULL},
	 { "delete_pairstringTImageBufferFormatReinterpreterMode", _wrap_delete_pairstringTImageBufferFormatReinterpreterMode, METH_O, NULL},
	 { "pairstringTImageBufferFormatReinterpreterMode_swigregister", pairstringTImageBufferFormatReinterpreterMode_swigregister, METH_O, NULL},
	 { "pairstringTImageBufferFormatReinterpreterMode_swiginit", pairstringTImageBufferFormatReinterpreterMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIImageDestinationPixelFormat", _wrap_new_PropertyIImageDestinationPixelFormat, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_getTranslationDict", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_getTranslationDictString", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_getTranslationDictValue", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_getTranslationDictStrings", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_getTranslationDictValues", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_getMaxValue", _wrap_PropertyIImageDestinationPixelFormat_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_getMinValue", _wrap_PropertyIImageDestinationPixelFormat_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_getStepWidth", _wrap_PropertyIImageDestinationPixelFormat_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_read", _wrap_PropertyIImageDestinationPixelFormat_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIImageDestinationPixelFormat_write", _wrap_PropertyIImageDestinationPixelFormat_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIImageDestinationPixelFormat", _wrap_delete_PropertyIImageDestinationPixelFormat, METH_O, NULL},
	 { "PropertyIImageDestinationPixelFormat_swigregister", PropertyIImageDestinationPixelFormat_swigregister, METH_O, NULL},
	 { "PropertyIImageDestinationPixelFormat_swiginit", PropertyIImageDestinationPixelFormat_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTImageDestinationPixelFormat", _wrap_new_pairstringTImageDestinationPixelFormat, METH_VARARGS, NULL},
	 { "pairstringTImageDestinationPixelFormat_first_set", _wrap_pairstringTImageDestinationPixelFormat_first_set, METH_VARARGS, NULL},
	 { "pairstringTImageDestinationPixelFormat_first_get", _wrap_pairstringTImageDestinationPixelFormat_first_get, METH_O, NULL},
	 { "pairstringTImageDestinationPixelFormat_second_set", _wrap_pairstringTImageDestinationPixelFormat_second_set, METH_VARARGS, NULL},
	 { "pairstringTImageDestinationPixelFormat_second_get", _wrap_pairstringTImageDestinationPixelFormat_second_get, METH_O, NULL},
	 { "delete_pairstringTImageDestinationPixelFormat", _wrap_delete_pairstringTImageDestinationPixelFormat, METH_O, NULL},
	 { "pairstringTImageDestinationPixelFormat_swigregister", pairstringTImageDestinationPixelFormat_swigregister, METH_O, NULL},
	 { "pairstringTImageDestinationPixelFormat_swiginit", pairstringTImageDestinationPixelFormat_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIImageProcessingFilter", _wrap_new_PropertyIImageProcessingFilter, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIImageProcessingFilter_getTranslationDict", _wrap_PropertyIImageProcessingFilter_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIImageProcessingFilter_getTranslationDictString", _wrap_PropertyIImageProcessingFilter_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageProcessingFilter_getTranslationDictValue", _wrap_PropertyIImageProcessingFilter_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageProcessingFilter_getTranslationDictStrings", _wrap_PropertyIImageProcessingFilter_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageProcessingFilter_getTranslationDictValues", _wrap_PropertyIImageProcessingFilter_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageProcessingFilter_getMaxValue", _wrap_PropertyIImageProcessingFilter_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingFilter_getMinValue", _wrap_PropertyIImageProcessingFilter_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingFilter_getStepWidth", _wrap_PropertyIImageProcessingFilter_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingFilter_read", _wrap_PropertyIImageProcessingFilter_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIImageProcessingFilter_write", _wrap_PropertyIImageProcessingFilter_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIImageProcessingFilter", _wrap_delete_PropertyIImageProcessingFilter, METH_O, NULL},
	 { "PropertyIImageProcessingFilter_swigregister", PropertyIImageProcessingFilter_swigregister, METH_O, NULL},
	 { "PropertyIImageProcessingFilter_swiginit", PropertyIImageProcessingFilter_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTImageProcessingFilter", _wrap_new_pairstringTImageProcessingFilter, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingFilter_first_set", _wrap_pairstringTImageProcessingFilter_first_set, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingFilter_first_get", _wrap_pairstringTImageProcessingFilter_first_get, METH_O, NULL},
	 { "pairstringTImageProcessingFilter_second_set", _wrap_pairstringTImageProcessingFilter_second_set, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingFilter_second_get", _wrap_pairstringTImageProcessingFilter_second_get, METH_O, NULL},
	 { "delete_pairstringTImageProcessingFilter", _wrap_delete_pairstringTImageProcessingFilter, METH_O, NULL},
	 { "pairstringTImageProcessingFilter_swigregister", pairstringTImageProcessingFilter_swigregister, METH_O, NULL},
	 { "pairstringTImageProcessingFilter_swiginit", pairstringTImageProcessingFilter_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIImageProcessingMode", _wrap_new_PropertyIImageProcessingMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIImageProcessingMode_getTranslationDict", _wrap_PropertyIImageProcessingMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIImageProcessingMode_getTranslationDictString", _wrap_PropertyIImageProcessingMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageProcessingMode_getTranslationDictValue", _wrap_PropertyIImageProcessingMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageProcessingMode_getTranslationDictStrings", _wrap_PropertyIImageProcessingMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageProcessingMode_getTranslationDictValues", _wrap_PropertyIImageProcessingMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageProcessingMode_getMaxValue", _wrap_PropertyIImageProcessingMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingMode_getMinValue", _wrap_PropertyIImageProcessingMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingMode_getStepWidth", _wrap_PropertyIImageProcessingMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingMode_read", _wrap_PropertyIImageProcessingMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIImageProcessingMode_write", _wrap_PropertyIImageProcessingMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIImageProcessingMode", _wrap_delete_PropertyIImageProcessingMode, METH_O, NULL},
	 { "PropertyIImageProcessingMode_swigregister", PropertyIImageProcessingMode_swigregister, METH_O, NULL},
	 { "PropertyIImageProcessingMode_swiginit", PropertyIImageProcessingMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTImageProcessingMode", _wrap_new_pairstringTImageProcessingMode, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingMode_first_set", _wrap_pairstringTImageProcessingMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingMode_first_get", _wrap_pairstringTImageProcessingMode_first_get, METH_O, NULL},
	 { "pairstringTImageProcessingMode_second_set", _wrap_pairstringTImageProcessingMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingMode_second_get", _wrap_pairstringTImageProcessingMode_second_get, METH_O, NULL},
	 { "delete_pairstringTImageProcessingMode", _wrap_delete_pairstringTImageProcessingMode, METH_O, NULL},
	 { "pairstringTImageProcessingMode_swigregister", pairstringTImageProcessingMode_swigregister, METH_O, NULL},
	 { "pairstringTImageProcessingMode_swiginit", pairstringTImageProcessingMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIImageProcessingOptimization", _wrap_new_PropertyIImageProcessingOptimization, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIImageProcessingOptimization_getTranslationDict", _wrap_PropertyIImageProcessingOptimization_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIImageProcessingOptimization_getTranslationDictString", _wrap_PropertyIImageProcessingOptimization_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageProcessingOptimization_getTranslationDictValue", _wrap_PropertyIImageProcessingOptimization_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageProcessingOptimization_getTranslationDictStrings", _wrap_PropertyIImageProcessingOptimization_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageProcessingOptimization_getTranslationDictValues", _wrap_PropertyIImageProcessingOptimization_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageProcessingOptimization_getMaxValue", _wrap_PropertyIImageProcessingOptimization_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingOptimization_getMinValue", _wrap_PropertyIImageProcessingOptimization_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingOptimization_getStepWidth", _wrap_PropertyIImageProcessingOptimization_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingOptimization_read", _wrap_PropertyIImageProcessingOptimization_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIImageProcessingOptimization_write", _wrap_PropertyIImageProcessingOptimization_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIImageProcessingOptimization", _wrap_delete_PropertyIImageProcessingOptimization, METH_O, NULL},
	 { "PropertyIImageProcessingOptimization_swigregister", PropertyIImageProcessingOptimization_swigregister, METH_O, NULL},
	 { "PropertyIImageProcessingOptimization_swiginit", PropertyIImageProcessingOptimization_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTImageProcessingOptimization", _wrap_new_pairstringTImageProcessingOptimization, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingOptimization_first_set", _wrap_pairstringTImageProcessingOptimization_first_set, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingOptimization_first_get", _wrap_pairstringTImageProcessingOptimization_first_get, METH_O, NULL},
	 { "pairstringTImageProcessingOptimization_second_set", _wrap_pairstringTImageProcessingOptimization_second_set, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingOptimization_second_get", _wrap_pairstringTImageProcessingOptimization_second_get, METH_O, NULL},
	 { "delete_pairstringTImageProcessingOptimization", _wrap_delete_pairstringTImageProcessingOptimization, METH_O, NULL},
	 { "pairstringTImageProcessingOptimization_swigregister", pairstringTImageProcessingOptimization_swigregister, METH_O, NULL},
	 { "pairstringTImageProcessingOptimization_swiginit", pairstringTImageProcessingOptimization_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIImageProcessingResult", _wrap_new_PropertyIImageProcessingResult, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIImageProcessingResult_getTranslationDict", _wrap_PropertyIImageProcessingResult_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIImageProcessingResult_getTranslationDictString", _wrap_PropertyIImageProcessingResult_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageProcessingResult_getTranslationDictValue", _wrap_PropertyIImageProcessingResult_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageProcessingResult_getTranslationDictStrings", _wrap_PropertyIImageProcessingResult_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageProcessingResult_getTranslationDictValues", _wrap_PropertyIImageProcessingResult_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageProcessingResult_getMaxValue", _wrap_PropertyIImageProcessingResult_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingResult_getMinValue", _wrap_PropertyIImageProcessingResult_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingResult_getStepWidth", _wrap_PropertyIImageProcessingResult_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageProcessingResult_read", _wrap_PropertyIImageProcessingResult_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIImageProcessingResult_write", _wrap_PropertyIImageProcessingResult_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIImageProcessingResult", _wrap_delete_PropertyIImageProcessingResult, METH_O, NULL},
	 { "PropertyIImageProcessingResult_swigregister", PropertyIImageProcessingResult_swigregister, METH_O, NULL},
	 { "PropertyIImageProcessingResult_swiginit", PropertyIImageProcessingResult_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTImageProcessingResult", _wrap_new_pairstringTImageProcessingResult, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingResult_first_set", _wrap_pairstringTImageProcessingResult_first_set, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingResult_first_get", _wrap_pairstringTImageProcessingResult_first_get, METH_O, NULL},
	 { "pairstringTImageProcessingResult_second_set", _wrap_pairstringTImageProcessingResult_second_set, METH_VARARGS, NULL},
	 { "pairstringTImageProcessingResult_second_get", _wrap_pairstringTImageProcessingResult_second_get, METH_O, NULL},
	 { "delete_pairstringTImageProcessingResult", _wrap_delete_pairstringTImageProcessingResult, METH_O, NULL},
	 { "pairstringTImageProcessingResult_swigregister", pairstringTImageProcessingResult_swigregister, METH_O, NULL},
	 { "pairstringTImageProcessingResult_swiginit", pairstringTImageProcessingResult_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIRequestImageMemoryMode", _wrap_new_PropertyIRequestImageMemoryMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIRequestImageMemoryMode_getTranslationDict", _wrap_PropertyIRequestImageMemoryMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIRequestImageMemoryMode_getTranslationDictString", _wrap_PropertyIRequestImageMemoryMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRequestImageMemoryMode_getTranslationDictValue", _wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRequestImageMemoryMode_getTranslationDictStrings", _wrap_PropertyIRequestImageMemoryMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRequestImageMemoryMode_getTranslationDictValues", _wrap_PropertyIRequestImageMemoryMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRequestImageMemoryMode_getMaxValue", _wrap_PropertyIRequestImageMemoryMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRequestImageMemoryMode_getMinValue", _wrap_PropertyIRequestImageMemoryMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRequestImageMemoryMode_getStepWidth", _wrap_PropertyIRequestImageMemoryMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRequestImageMemoryMode_read", _wrap_PropertyIRequestImageMemoryMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIRequestImageMemoryMode_write", _wrap_PropertyIRequestImageMemoryMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIRequestImageMemoryMode", _wrap_delete_PropertyIRequestImageMemoryMode, METH_O, NULL},
	 { "PropertyIRequestImageMemoryMode_swigregister", PropertyIRequestImageMemoryMode_swigregister, METH_O, NULL},
	 { "PropertyIRequestImageMemoryMode_swiginit", PropertyIRequestImageMemoryMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTRequestImageMemoryMode", _wrap_new_pairstringTRequestImageMemoryMode, METH_VARARGS, NULL},
	 { "pairstringTRequestImageMemoryMode_first_set", _wrap_pairstringTRequestImageMemoryMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTRequestImageMemoryMode_first_get", _wrap_pairstringTRequestImageMemoryMode_first_get, METH_O, NULL},
	 { "pairstringTRequestImageMemoryMode_second_set", _wrap_pairstringTRequestImageMemoryMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTRequestImageMemoryMode_second_get", _wrap_pairstringTRequestImageMemoryMode_second_get, METH_O, NULL},
	 { "delete_pairstringTRequestImageMemoryMode", _wrap_delete_pairstringTRequestImageMemoryMode, METH_O, NULL},
	 { "pairstringTRequestImageMemoryMode_swigregister", pairstringTRequestImageMemoryMode_swigregister, METH_O, NULL},
	 { "pairstringTRequestImageMemoryMode_swiginit", pairstringTRequestImageMemoryMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIImageRequestControlMode", _wrap_new_PropertyIImageRequestControlMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIImageRequestControlMode_getTranslationDict", _wrap_PropertyIImageRequestControlMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIImageRequestControlMode_getTranslationDictString", _wrap_PropertyIImageRequestControlMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageRequestControlMode_getTranslationDictValue", _wrap_PropertyIImageRequestControlMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIImageRequestControlMode_getTranslationDictStrings", _wrap_PropertyIImageRequestControlMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageRequestControlMode_getTranslationDictValues", _wrap_PropertyIImageRequestControlMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIImageRequestControlMode_getMaxValue", _wrap_PropertyIImageRequestControlMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageRequestControlMode_getMinValue", _wrap_PropertyIImageRequestControlMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageRequestControlMode_getStepWidth", _wrap_PropertyIImageRequestControlMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIImageRequestControlMode_read", _wrap_PropertyIImageRequestControlMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIImageRequestControlMode_write", _wrap_PropertyIImageRequestControlMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIImageRequestControlMode", _wrap_delete_PropertyIImageRequestControlMode, METH_O, NULL},
	 { "PropertyIImageRequestControlMode_swigregister", PropertyIImageRequestControlMode_swigregister, METH_O, NULL},
	 { "PropertyIImageRequestControlMode_swiginit", PropertyIImageRequestControlMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTImageRequestControlMode", _wrap_new_pairstringTImageRequestControlMode, METH_VARARGS, NULL},
	 { "pairstringTImageRequestControlMode_first_set", _wrap_pairstringTImageRequestControlMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTImageRequestControlMode_first_get", _wrap_pairstringTImageRequestControlMode_first_get, METH_O, NULL},
	 { "pairstringTImageRequestControlMode_second_set", _wrap_pairstringTImageRequestControlMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTImageRequestControlMode_second_get", _wrap_pairstringTImageRequestControlMode_second_get, METH_O, NULL},
	 { "delete_pairstringTImageRequestControlMode", _wrap_delete_pairstringTImageRequestControlMode, METH_O, NULL},
	 { "pairstringTImageRequestControlMode_swigregister", pairstringTImageRequestControlMode_swigregister, METH_O, NULL},
	 { "pairstringTImageRequestControlMode_swiginit", pairstringTImageRequestControlMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIInfoSensorColorMode", _wrap_new_PropertyIInfoSensorColorMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIInfoSensorColorMode_getTranslationDict", _wrap_PropertyIInfoSensorColorMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIInfoSensorColorMode_getTranslationDictString", _wrap_PropertyIInfoSensorColorMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIInfoSensorColorMode_getTranslationDictValue", _wrap_PropertyIInfoSensorColorMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIInfoSensorColorMode_getTranslationDictStrings", _wrap_PropertyIInfoSensorColorMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIInfoSensorColorMode_getTranslationDictValues", _wrap_PropertyIInfoSensorColorMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIInfoSensorColorMode_getMaxValue", _wrap_PropertyIInfoSensorColorMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInfoSensorColorMode_getMinValue", _wrap_PropertyIInfoSensorColorMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInfoSensorColorMode_getStepWidth", _wrap_PropertyIInfoSensorColorMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInfoSensorColorMode_read", _wrap_PropertyIInfoSensorColorMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIInfoSensorColorMode_write", _wrap_PropertyIInfoSensorColorMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIInfoSensorColorMode", _wrap_delete_PropertyIInfoSensorColorMode, METH_O, NULL},
	 { "PropertyIInfoSensorColorMode_swigregister", PropertyIInfoSensorColorMode_swigregister, METH_O, NULL},
	 { "PropertyIInfoSensorColorMode_swiginit", PropertyIInfoSensorColorMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTInfoSensorColorMode", _wrap_new_pairstringTInfoSensorColorMode, METH_VARARGS, NULL},
	 { "pairstringTInfoSensorColorMode_first_set", _wrap_pairstringTInfoSensorColorMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTInfoSensorColorMode_first_get", _wrap_pairstringTInfoSensorColorMode_first_get, METH_O, NULL},
	 { "pairstringTInfoSensorColorMode_second_set", _wrap_pairstringTInfoSensorColorMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTInfoSensorColorMode_second_get", _wrap_pairstringTInfoSensorColorMode_second_get, METH_O, NULL},
	 { "delete_pairstringTInfoSensorColorMode", _wrap_delete_pairstringTInfoSensorColorMode, METH_O, NULL},
	 { "pairstringTInfoSensorColorMode_swigregister", pairstringTInfoSensorColorMode_swigregister, METH_O, NULL},
	 { "pairstringTInfoSensorColorMode_swiginit", pairstringTInfoSensorColorMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIInfoSensorType", _wrap_new_PropertyIInfoSensorType, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIInfoSensorType_getTranslationDict", _wrap_PropertyIInfoSensorType_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIInfoSensorType_getTranslationDictString", _wrap_PropertyIInfoSensorType_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIInfoSensorType_getTranslationDictValue", _wrap_PropertyIInfoSensorType_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIInfoSensorType_getTranslationDictStrings", _wrap_PropertyIInfoSensorType_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIInfoSensorType_getTranslationDictValues", _wrap_PropertyIInfoSensorType_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIInfoSensorType_getMaxValue", _wrap_PropertyIInfoSensorType_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInfoSensorType_getMinValue", _wrap_PropertyIInfoSensorType_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInfoSensorType_getStepWidth", _wrap_PropertyIInfoSensorType_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInfoSensorType_read", _wrap_PropertyIInfoSensorType_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIInfoSensorType_write", _wrap_PropertyIInfoSensorType_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIInfoSensorType", _wrap_delete_PropertyIInfoSensorType, METH_O, NULL},
	 { "PropertyIInfoSensorType_swigregister", PropertyIInfoSensorType_swigregister, METH_O, NULL},
	 { "PropertyIInfoSensorType_swiginit", PropertyIInfoSensorType_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTInfoSensorType", _wrap_new_pairstringTInfoSensorType, METH_VARARGS, NULL},
	 { "pairstringTInfoSensorType_first_set", _wrap_pairstringTInfoSensorType_first_set, METH_VARARGS, NULL},
	 { "pairstringTInfoSensorType_first_get", _wrap_pairstringTInfoSensorType_first_get, METH_O, NULL},
	 { "pairstringTInfoSensorType_second_set", _wrap_pairstringTInfoSensorType_second_set, METH_VARARGS, NULL},
	 { "pairstringTInfoSensorType_second_get", _wrap_pairstringTInfoSensorType_second_get, METH_O, NULL},
	 { "delete_pairstringTInfoSensorType", _wrap_delete_pairstringTInfoSensorType, METH_O, NULL},
	 { "pairstringTInfoSensorType_swigregister", pairstringTInfoSensorType_swigregister, METH_O, NULL},
	 { "pairstringTInfoSensorType_swiginit", pairstringTInfoSensorType_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIInterfaceEnumerationBehaviour", _wrap_new_PropertyIInterfaceEnumerationBehaviour, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_getTranslationDict", _wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_getTranslationDictString", _wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue", _wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_getTranslationDictStrings", _wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_getTranslationDictValues", _wrap_PropertyIInterfaceEnumerationBehaviour_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_getMaxValue", _wrap_PropertyIInterfaceEnumerationBehaviour_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_getMinValue", _wrap_PropertyIInterfaceEnumerationBehaviour_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_getStepWidth", _wrap_PropertyIInterfaceEnumerationBehaviour_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_read", _wrap_PropertyIInterfaceEnumerationBehaviour_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIInterfaceEnumerationBehaviour_write", _wrap_PropertyIInterfaceEnumerationBehaviour_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIInterfaceEnumerationBehaviour", _wrap_delete_PropertyIInterfaceEnumerationBehaviour, METH_O, NULL},
	 { "PropertyIInterfaceEnumerationBehaviour_swigregister", PropertyIInterfaceEnumerationBehaviour_swigregister, METH_O, NULL},
	 { "PropertyIInterfaceEnumerationBehaviour_swiginit", PropertyIInterfaceEnumerationBehaviour_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTInterfaceEnumerationBehaviour", _wrap_new_pairstringTInterfaceEnumerationBehaviour, METH_VARARGS, NULL},
	 { "pairstringTInterfaceEnumerationBehaviour_first_set", _wrap_pairstringTInterfaceEnumerationBehaviour_first_set, METH_VARARGS, NULL},
	 { "pairstringTInterfaceEnumerationBehaviour_first_get", _wrap_pairstringTInterfaceEnumerationBehaviour_first_get, METH_O, NULL},
	 { "pairstringTInterfaceEnumerationBehaviour_second_set", _wrap_pairstringTInterfaceEnumerationBehaviour_second_set, METH_VARARGS, NULL},
	 { "pairstringTInterfaceEnumerationBehaviour_second_get", _wrap_pairstringTInterfaceEnumerationBehaviour_second_get, METH_O, NULL},
	 { "delete_pairstringTInterfaceEnumerationBehaviour", _wrap_delete_pairstringTInterfaceEnumerationBehaviour, METH_O, NULL},
	 { "pairstringTInterfaceEnumerationBehaviour_swigregister", pairstringTInterfaceEnumerationBehaviour_swigregister, METH_O, NULL},
	 { "pairstringTInterfaceEnumerationBehaviour_swiginit", pairstringTInterfaceEnumerationBehaviour_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIInterlacedMode", _wrap_new_PropertyIInterlacedMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIInterlacedMode_getTranslationDict", _wrap_PropertyIInterlacedMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIInterlacedMode_getTranslationDictString", _wrap_PropertyIInterlacedMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIInterlacedMode_getTranslationDictValue", _wrap_PropertyIInterlacedMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIInterlacedMode_getTranslationDictStrings", _wrap_PropertyIInterlacedMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIInterlacedMode_getTranslationDictValues", _wrap_PropertyIInterlacedMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIInterlacedMode_getMaxValue", _wrap_PropertyIInterlacedMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInterlacedMode_getMinValue", _wrap_PropertyIInterlacedMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInterlacedMode_getStepWidth", _wrap_PropertyIInterlacedMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIInterlacedMode_read", _wrap_PropertyIInterlacedMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIInterlacedMode_write", _wrap_PropertyIInterlacedMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIInterlacedMode", _wrap_delete_PropertyIInterlacedMode, METH_O, NULL},
	 { "PropertyIInterlacedMode_swigregister", PropertyIInterlacedMode_swigregister, METH_O, NULL},
	 { "PropertyIInterlacedMode_swiginit", PropertyIInterlacedMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTInterlacedMode", _wrap_new_pairstringTInterlacedMode, METH_VARARGS, NULL},
	 { "pairstringTInterlacedMode_first_set", _wrap_pairstringTInterlacedMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTInterlacedMode_first_get", _wrap_pairstringTInterlacedMode_first_get, METH_O, NULL},
	 { "pairstringTInterlacedMode_second_set", _wrap_pairstringTInterlacedMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTInterlacedMode_second_get", _wrap_pairstringTInterlacedMode_second_get, METH_O, NULL},
	 { "delete_pairstringTInterlacedMode", _wrap_delete_pairstringTInterlacedMode, METH_O, NULL},
	 { "pairstringTInterlacedMode_swigregister", pairstringTInterlacedMode_swigregister, METH_O, NULL},
	 { "pairstringTInterlacedMode_swiginit", pairstringTInterlacedMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyILineCounter", _wrap_new_PropertyILineCounter, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyILineCounter_getTranslationDict", _wrap_PropertyILineCounter_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLineCounter >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLineCounter > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyILineCounter_getTranslationDictString", _wrap_PropertyILineCounter_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILineCounter_getTranslationDictValue", _wrap_PropertyILineCounter_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILineCounter_getTranslationDictStrings", _wrap_PropertyILineCounter_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILineCounter_getTranslationDictValues", _wrap_PropertyILineCounter_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILineCounter_getMaxValue", _wrap_PropertyILineCounter_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILineCounter_getMinValue", _wrap_PropertyILineCounter_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILineCounter_getStepWidth", _wrap_PropertyILineCounter_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILineCounter_read", _wrap_PropertyILineCounter_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyILineCounter_write", _wrap_PropertyILineCounter_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyILineCounter", _wrap_delete_PropertyILineCounter, METH_O, NULL},
	 { "PropertyILineCounter_swigregister", PropertyILineCounter_swigregister, METH_O, NULL},
	 { "PropertyILineCounter_swiginit", PropertyILineCounter_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTLineCounter", _wrap_new_pairstringTLineCounter, METH_VARARGS, NULL},
	 { "pairstringTLineCounter_first_set", _wrap_pairstringTLineCounter_first_set, METH_VARARGS, NULL},
	 { "pairstringTLineCounter_first_get", _wrap_pairstringTLineCounter_first_get, METH_O, NULL},
	 { "pairstringTLineCounter_second_set", _wrap_pairstringTLineCounter_second_set, METH_VARARGS, NULL},
	 { "pairstringTLineCounter_second_get", _wrap_pairstringTLineCounter_second_get, METH_O, NULL},
	 { "delete_pairstringTLineCounter", _wrap_delete_pairstringTLineCounter, METH_O, NULL},
	 { "pairstringTLineCounter_swigregister", pairstringTLineCounter_swigregister, METH_O, NULL},
	 { "pairstringTLineCounter_swiginit", pairstringTLineCounter_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyILUTGammaMode", _wrap_new_PropertyILUTGammaMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyILUTGammaMode_getTranslationDict", _wrap_PropertyILUTGammaMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyILUTGammaMode_getTranslationDictString", _wrap_PropertyILUTGammaMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTGammaMode_getTranslationDictValue", _wrap_PropertyILUTGammaMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTGammaMode_getTranslationDictStrings", _wrap_PropertyILUTGammaMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTGammaMode_getTranslationDictValues", _wrap_PropertyILUTGammaMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTGammaMode_getMaxValue", _wrap_PropertyILUTGammaMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTGammaMode_getMinValue", _wrap_PropertyILUTGammaMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTGammaMode_getStepWidth", _wrap_PropertyILUTGammaMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTGammaMode_read", _wrap_PropertyILUTGammaMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyILUTGammaMode_write", _wrap_PropertyILUTGammaMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyILUTGammaMode", _wrap_delete_PropertyILUTGammaMode, METH_O, NULL},
	 { "PropertyILUTGammaMode_swigregister", PropertyILUTGammaMode_swigregister, METH_O, NULL},
	 { "PropertyILUTGammaMode_swiginit", PropertyILUTGammaMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTLUTGammaMode", _wrap_new_pairstringTLUTGammaMode, METH_VARARGS, NULL},
	 { "pairstringTLUTGammaMode_first_set", _wrap_pairstringTLUTGammaMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTLUTGammaMode_first_get", _wrap_pairstringTLUTGammaMode_first_get, METH_O, NULL},
	 { "pairstringTLUTGammaMode_second_set", _wrap_pairstringTLUTGammaMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTLUTGammaMode_second_get", _wrap_pairstringTLUTGammaMode_second_get, METH_O, NULL},
	 { "delete_pairstringTLUTGammaMode", _wrap_delete_pairstringTLUTGammaMode, METH_O, NULL},
	 { "pairstringTLUTGammaMode_swigregister", pairstringTLUTGammaMode_swigregister, METH_O, NULL},
	 { "pairstringTLUTGammaMode_swiginit", pairstringTLUTGammaMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyILUTImplementation", _wrap_new_PropertyILUTImplementation, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyILUTImplementation_getTranslationDict", _wrap_PropertyILUTImplementation_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyILUTImplementation_getTranslationDictString", _wrap_PropertyILUTImplementation_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTImplementation_getTranslationDictValue", _wrap_PropertyILUTImplementation_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTImplementation_getTranslationDictStrings", _wrap_PropertyILUTImplementation_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTImplementation_getTranslationDictValues", _wrap_PropertyILUTImplementation_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTImplementation_getMaxValue", _wrap_PropertyILUTImplementation_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTImplementation_getMinValue", _wrap_PropertyILUTImplementation_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTImplementation_getStepWidth", _wrap_PropertyILUTImplementation_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTImplementation_read", _wrap_PropertyILUTImplementation_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyILUTImplementation_write", _wrap_PropertyILUTImplementation_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyILUTImplementation", _wrap_delete_PropertyILUTImplementation, METH_O, NULL},
	 { "PropertyILUTImplementation_swigregister", PropertyILUTImplementation_swigregister, METH_O, NULL},
	 { "PropertyILUTImplementation_swiginit", PropertyILUTImplementation_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTLUTImplementation", _wrap_new_pairstringTLUTImplementation, METH_VARARGS, NULL},
	 { "pairstringTLUTImplementation_first_set", _wrap_pairstringTLUTImplementation_first_set, METH_VARARGS, NULL},
	 { "pairstringTLUTImplementation_first_get", _wrap_pairstringTLUTImplementation_first_get, METH_O, NULL},
	 { "pairstringTLUTImplementation_second_set", _wrap_pairstringTLUTImplementation_second_set, METH_VARARGS, NULL},
	 { "pairstringTLUTImplementation_second_get", _wrap_pairstringTLUTImplementation_second_get, METH_O, NULL},
	 { "delete_pairstringTLUTImplementation", _wrap_delete_pairstringTLUTImplementation, METH_O, NULL},
	 { "pairstringTLUTImplementation_swigregister", pairstringTLUTImplementation_swigregister, METH_O, NULL},
	 { "pairstringTLUTImplementation_swiginit", pairstringTLUTImplementation_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyILUTInterpolationMode", _wrap_new_PropertyILUTInterpolationMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyILUTInterpolationMode_getTranslationDict", _wrap_PropertyILUTInterpolationMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyILUTInterpolationMode_getTranslationDictString", _wrap_PropertyILUTInterpolationMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTInterpolationMode_getTranslationDictValue", _wrap_PropertyILUTInterpolationMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTInterpolationMode_getTranslationDictStrings", _wrap_PropertyILUTInterpolationMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTInterpolationMode_getTranslationDictValues", _wrap_PropertyILUTInterpolationMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTInterpolationMode_getMaxValue", _wrap_PropertyILUTInterpolationMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTInterpolationMode_getMinValue", _wrap_PropertyILUTInterpolationMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTInterpolationMode_getStepWidth", _wrap_PropertyILUTInterpolationMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTInterpolationMode_read", _wrap_PropertyILUTInterpolationMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyILUTInterpolationMode_write", _wrap_PropertyILUTInterpolationMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyILUTInterpolationMode", _wrap_delete_PropertyILUTInterpolationMode, METH_O, NULL},
	 { "PropertyILUTInterpolationMode_swigregister", PropertyILUTInterpolationMode_swigregister, METH_O, NULL},
	 { "PropertyILUTInterpolationMode_swiginit", PropertyILUTInterpolationMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTLUTInterpolationMode", _wrap_new_pairstringTLUTInterpolationMode, METH_VARARGS, NULL},
	 { "pairstringTLUTInterpolationMode_first_set", _wrap_pairstringTLUTInterpolationMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTLUTInterpolationMode_first_get", _wrap_pairstringTLUTInterpolationMode_first_get, METH_O, NULL},
	 { "pairstringTLUTInterpolationMode_second_set", _wrap_pairstringTLUTInterpolationMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTLUTInterpolationMode_second_get", _wrap_pairstringTLUTInterpolationMode_second_get, METH_O, NULL},
	 { "delete_pairstringTLUTInterpolationMode", _wrap_delete_pairstringTLUTInterpolationMode, METH_O, NULL},
	 { "pairstringTLUTInterpolationMode_swigregister", pairstringTLUTInterpolationMode_swigregister, METH_O, NULL},
	 { "pairstringTLUTInterpolationMode_swiginit", pairstringTLUTInterpolationMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyILUTMapping", _wrap_new_PropertyILUTMapping, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyILUTMapping_getTranslationDict", _wrap_PropertyILUTMapping_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMapping >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyILUTMapping_getTranslationDictString", _wrap_PropertyILUTMapping_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTMapping_getTranslationDictValue", _wrap_PropertyILUTMapping_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTMapping_getTranslationDictStrings", _wrap_PropertyILUTMapping_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTMapping_getTranslationDictValues", _wrap_PropertyILUTMapping_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTMapping_getMaxValue", _wrap_PropertyILUTMapping_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTMapping_getMinValue", _wrap_PropertyILUTMapping_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTMapping_getStepWidth", _wrap_PropertyILUTMapping_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTMapping_read", _wrap_PropertyILUTMapping_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyILUTMapping_write", _wrap_PropertyILUTMapping_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyILUTMapping", _wrap_delete_PropertyILUTMapping, METH_O, NULL},
	 { "PropertyILUTMapping_swigregister", PropertyILUTMapping_swigregister, METH_O, NULL},
	 { "PropertyILUTMapping_swiginit", PropertyILUTMapping_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTLUTMapping", _wrap_new_pairstringTLUTMapping, METH_VARARGS, NULL},
	 { "pairstringTLUTMapping_first_set", _wrap_pairstringTLUTMapping_first_set, METH_VARARGS, NULL},
	 { "pairstringTLUTMapping_first_get", _wrap_pairstringTLUTMapping_first_get, METH_O, NULL},
	 { "pairstringTLUTMapping_second_set", _wrap_pairstringTLUTMapping_second_set, METH_VARARGS, NULL},
	 { "pairstringTLUTMapping_second_get", _wrap_pairstringTLUTMapping_second_get, METH_O, NULL},
	 { "delete_pairstringTLUTMapping", _wrap_delete_pairstringTLUTMapping, METH_O, NULL},
	 { "pairstringTLUTMapping_swigregister", pairstringTLUTMapping_swigregister, METH_O, NULL},
	 { "pairstringTLUTMapping_swiginit", pairstringTLUTMapping_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyILUTMode", _wrap_new_PropertyILUTMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyILUTMode_getTranslationDict", _wrap_PropertyILUTMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyILUTMode_getTranslationDictString", _wrap_PropertyILUTMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTMode_getTranslationDictValue", _wrap_PropertyILUTMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyILUTMode_getTranslationDictStrings", _wrap_PropertyILUTMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTMode_getTranslationDictValues", _wrap_PropertyILUTMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyILUTMode_getMaxValue", _wrap_PropertyILUTMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTMode_getMinValue", _wrap_PropertyILUTMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTMode_getStepWidth", _wrap_PropertyILUTMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyILUTMode_read", _wrap_PropertyILUTMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyILUTMode_write", _wrap_PropertyILUTMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyILUTMode", _wrap_delete_PropertyILUTMode, METH_O, NULL},
	 { "PropertyILUTMode_swigregister", PropertyILUTMode_swigregister, METH_O, NULL},
	 { "PropertyILUTMode_swiginit", PropertyILUTMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTLUTMode", _wrap_new_pairstringTLUTMode, METH_VARARGS, NULL},
	 { "pairstringTLUTMode_first_set", _wrap_pairstringTLUTMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTLUTMode_first_get", _wrap_pairstringTLUTMode_first_get, METH_O, NULL},
	 { "pairstringTLUTMode_second_set", _wrap_pairstringTLUTMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTLUTMode_second_get", _wrap_pairstringTLUTMode_second_get, METH_O, NULL},
	 { "delete_pairstringTLUTMode", _wrap_delete_pairstringTLUTMode, METH_O, NULL},
	 { "pairstringTLUTMode_swigregister", pairstringTLUTMode_swigregister, METH_O, NULL},
	 { "pairstringTLUTMode_swiginit", pairstringTLUTMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIMemoryManagerMode", _wrap_new_PropertyIMemoryManagerMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIMemoryManagerMode_getTranslationDict", _wrap_PropertyIMemoryManagerMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIMemoryManagerMode_getTranslationDictString", _wrap_PropertyIMemoryManagerMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIMemoryManagerMode_getTranslationDictValue", _wrap_PropertyIMemoryManagerMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIMemoryManagerMode_getTranslationDictStrings", _wrap_PropertyIMemoryManagerMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIMemoryManagerMode_getTranslationDictValues", _wrap_PropertyIMemoryManagerMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIMemoryManagerMode_getMaxValue", _wrap_PropertyIMemoryManagerMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMemoryManagerMode_getMinValue", _wrap_PropertyIMemoryManagerMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMemoryManagerMode_getStepWidth", _wrap_PropertyIMemoryManagerMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMemoryManagerMode_read", _wrap_PropertyIMemoryManagerMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIMemoryManagerMode_write", _wrap_PropertyIMemoryManagerMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIMemoryManagerMode", _wrap_delete_PropertyIMemoryManagerMode, METH_O, NULL},
	 { "PropertyIMemoryManagerMode_swigregister", PropertyIMemoryManagerMode_swigregister, METH_O, NULL},
	 { "PropertyIMemoryManagerMode_swiginit", PropertyIMemoryManagerMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTMemoryManagerMode", _wrap_new_pairstringTMemoryManagerMode, METH_VARARGS, NULL},
	 { "pairstringTMemoryManagerMode_first_set", _wrap_pairstringTMemoryManagerMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTMemoryManagerMode_first_get", _wrap_pairstringTMemoryManagerMode_first_get, METH_O, NULL},
	 { "pairstringTMemoryManagerMode_second_set", _wrap_pairstringTMemoryManagerMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTMemoryManagerMode_second_get", _wrap_pairstringTMemoryManagerMode_second_get, METH_O, NULL},
	 { "delete_pairstringTMemoryManagerMode", _wrap_delete_pairstringTMemoryManagerMode, METH_O, NULL},
	 { "pairstringTMemoryManagerMode_swigregister", pairstringTMemoryManagerMode_swigregister, METH_O, NULL},
	 { "pairstringTMemoryManagerMode_swiginit", pairstringTMemoryManagerMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIMemoryManagerPoolMode", _wrap_new_PropertyIMemoryManagerPoolMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_getTranslationDict", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_getTranslationDictString", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_getTranslationDictValue", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_getTranslationDictStrings", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_getTranslationDictValues", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_getMaxValue", _wrap_PropertyIMemoryManagerPoolMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_getMinValue", _wrap_PropertyIMemoryManagerPoolMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_getStepWidth", _wrap_PropertyIMemoryManagerPoolMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_read", _wrap_PropertyIMemoryManagerPoolMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIMemoryManagerPoolMode_write", _wrap_PropertyIMemoryManagerPoolMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIMemoryManagerPoolMode", _wrap_delete_PropertyIMemoryManagerPoolMode, METH_O, NULL},
	 { "PropertyIMemoryManagerPoolMode_swigregister", PropertyIMemoryManagerPoolMode_swigregister, METH_O, NULL},
	 { "PropertyIMemoryManagerPoolMode_swiginit", PropertyIMemoryManagerPoolMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTMemoryManagerPoolMode", _wrap_new_pairstringTMemoryManagerPoolMode, METH_VARARGS, NULL},
	 { "pairstringTMemoryManagerPoolMode_first_set", _wrap_pairstringTMemoryManagerPoolMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTMemoryManagerPoolMode_first_get", _wrap_pairstringTMemoryManagerPoolMode_first_get, METH_O, NULL},
	 { "pairstringTMemoryManagerPoolMode_second_set", _wrap_pairstringTMemoryManagerPoolMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTMemoryManagerPoolMode_second_get", _wrap_pairstringTMemoryManagerPoolMode_second_get, METH_O, NULL},
	 { "delete_pairstringTMemoryManagerPoolMode", _wrap_delete_pairstringTMemoryManagerPoolMode, METH_O, NULL},
	 { "pairstringTMemoryManagerPoolMode_swigregister", pairstringTMemoryManagerPoolMode_swigregister, METH_O, NULL},
	 { "pairstringTMemoryManagerPoolMode_swiginit", pairstringTMemoryManagerPoolMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIMirrorMode", _wrap_new_PropertyIMirrorMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIMirrorMode_getTranslationDict", _wrap_PropertyIMirrorMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIMirrorMode_getTranslationDictString", _wrap_PropertyIMirrorMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIMirrorMode_getTranslationDictValue", _wrap_PropertyIMirrorMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIMirrorMode_getTranslationDictStrings", _wrap_PropertyIMirrorMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIMirrorMode_getTranslationDictValues", _wrap_PropertyIMirrorMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIMirrorMode_getMaxValue", _wrap_PropertyIMirrorMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMirrorMode_getMinValue", _wrap_PropertyIMirrorMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMirrorMode_getStepWidth", _wrap_PropertyIMirrorMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMirrorMode_read", _wrap_PropertyIMirrorMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIMirrorMode_write", _wrap_PropertyIMirrorMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIMirrorMode", _wrap_delete_PropertyIMirrorMode, METH_O, NULL},
	 { "PropertyIMirrorMode_swigregister", PropertyIMirrorMode_swigregister, METH_O, NULL},
	 { "PropertyIMirrorMode_swiginit", PropertyIMirrorMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTMirrorMode", _wrap_new_pairstringTMirrorMode, METH_VARARGS, NULL},
	 { "pairstringTMirrorMode_first_set", _wrap_pairstringTMirrorMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTMirrorMode_first_get", _wrap_pairstringTMirrorMode_first_get, METH_O, NULL},
	 { "pairstringTMirrorMode_second_set", _wrap_pairstringTMirrorMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTMirrorMode_second_get", _wrap_pairstringTMirrorMode_second_get, METH_O, NULL},
	 { "delete_pairstringTMirrorMode", _wrap_delete_pairstringTMirrorMode, METH_O, NULL},
	 { "pairstringTMirrorMode_swigregister", pairstringTMirrorMode_swigregister, METH_O, NULL},
	 { "pairstringTMirrorMode_swiginit", pairstringTMirrorMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIMirrorOperationMode", _wrap_new_PropertyIMirrorOperationMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIMirrorOperationMode_getTranslationDict", _wrap_PropertyIMirrorOperationMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIMirrorOperationMode_getTranslationDictString", _wrap_PropertyIMirrorOperationMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIMirrorOperationMode_getTranslationDictValue", _wrap_PropertyIMirrorOperationMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIMirrorOperationMode_getTranslationDictStrings", _wrap_PropertyIMirrorOperationMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIMirrorOperationMode_getTranslationDictValues", _wrap_PropertyIMirrorOperationMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIMirrorOperationMode_getMaxValue", _wrap_PropertyIMirrorOperationMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMirrorOperationMode_getMinValue", _wrap_PropertyIMirrorOperationMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMirrorOperationMode_getStepWidth", _wrap_PropertyIMirrorOperationMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIMirrorOperationMode_read", _wrap_PropertyIMirrorOperationMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIMirrorOperationMode_write", _wrap_PropertyIMirrorOperationMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIMirrorOperationMode", _wrap_delete_PropertyIMirrorOperationMode, METH_O, NULL},
	 { "PropertyIMirrorOperationMode_swigregister", PropertyIMirrorOperationMode_swigregister, METH_O, NULL},
	 { "PropertyIMirrorOperationMode_swiginit", PropertyIMirrorOperationMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTMirrorOperationMode", _wrap_new_pairstringTMirrorOperationMode, METH_VARARGS, NULL},
	 { "pairstringTMirrorOperationMode_first_set", _wrap_pairstringTMirrorOperationMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTMirrorOperationMode_first_get", _wrap_pairstringTMirrorOperationMode_first_get, METH_O, NULL},
	 { "pairstringTMirrorOperationMode_second_set", _wrap_pairstringTMirrorOperationMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTMirrorOperationMode_second_get", _wrap_pairstringTMirrorOperationMode_second_get, METH_O, NULL},
	 { "delete_pairstringTMirrorOperationMode", _wrap_delete_pairstringTMirrorOperationMode, METH_O, NULL},
	 { "pairstringTMirrorOperationMode_swigregister", pairstringTMirrorOperationMode_swigregister, METH_O, NULL},
	 { "pairstringTMirrorOperationMode_swiginit", pairstringTMirrorOperationMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIOnBoardMemoryMode", _wrap_new_PropertyIOnBoardMemoryMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIOnBoardMemoryMode_getTranslationDict", _wrap_PropertyIOnBoardMemoryMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIOnBoardMemoryMode_getTranslationDictString", _wrap_PropertyIOnBoardMemoryMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIOnBoardMemoryMode_getTranslationDictValue", _wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIOnBoardMemoryMode_getTranslationDictStrings", _wrap_PropertyIOnBoardMemoryMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIOnBoardMemoryMode_getTranslationDictValues", _wrap_PropertyIOnBoardMemoryMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIOnBoardMemoryMode_getMaxValue", _wrap_PropertyIOnBoardMemoryMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIOnBoardMemoryMode_getMinValue", _wrap_PropertyIOnBoardMemoryMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIOnBoardMemoryMode_getStepWidth", _wrap_PropertyIOnBoardMemoryMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIOnBoardMemoryMode_read", _wrap_PropertyIOnBoardMemoryMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIOnBoardMemoryMode_write", _wrap_PropertyIOnBoardMemoryMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIOnBoardMemoryMode", _wrap_delete_PropertyIOnBoardMemoryMode, METH_O, NULL},
	 { "PropertyIOnBoardMemoryMode_swigregister", PropertyIOnBoardMemoryMode_swigregister, METH_O, NULL},
	 { "PropertyIOnBoardMemoryMode_swiginit", PropertyIOnBoardMemoryMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTOnBoardMemoryMode", _wrap_new_pairstringTOnBoardMemoryMode, METH_VARARGS, NULL},
	 { "pairstringTOnBoardMemoryMode_first_set", _wrap_pairstringTOnBoardMemoryMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTOnBoardMemoryMode_first_get", _wrap_pairstringTOnBoardMemoryMode_first_get, METH_O, NULL},
	 { "pairstringTOnBoardMemoryMode_second_set", _wrap_pairstringTOnBoardMemoryMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTOnBoardMemoryMode_second_get", _wrap_pairstringTOnBoardMemoryMode_second_get, METH_O, NULL},
	 { "delete_pairstringTOnBoardMemoryMode", _wrap_delete_pairstringTOnBoardMemoryMode, METH_O, NULL},
	 { "pairstringTOnBoardMemoryMode_swigregister", pairstringTOnBoardMemoryMode_swigregister, METH_O, NULL},
	 { "pairstringTOnBoardMemoryMode_swiginit", pairstringTOnBoardMemoryMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIPolarizedDataExtractionMode", _wrap_new_PropertyIPolarizedDataExtractionMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_getTranslationDict", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_getTranslationDictString", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_getTranslationDictValue", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_getTranslationDictStrings", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_getTranslationDictValues", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_getMaxValue", _wrap_PropertyIPolarizedDataExtractionMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_getMinValue", _wrap_PropertyIPolarizedDataExtractionMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_getStepWidth", _wrap_PropertyIPolarizedDataExtractionMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_read", _wrap_PropertyIPolarizedDataExtractionMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIPolarizedDataExtractionMode_write", _wrap_PropertyIPolarizedDataExtractionMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIPolarizedDataExtractionMode", _wrap_delete_PropertyIPolarizedDataExtractionMode, METH_O, NULL},
	 { "PropertyIPolarizedDataExtractionMode_swigregister", PropertyIPolarizedDataExtractionMode_swigregister, METH_O, NULL},
	 { "PropertyIPolarizedDataExtractionMode_swiginit", PropertyIPolarizedDataExtractionMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTPolarizedDataExtractionMode", _wrap_new_pairstringTPolarizedDataExtractionMode, METH_VARARGS, NULL},
	 { "pairstringTPolarizedDataExtractionMode_first_set", _wrap_pairstringTPolarizedDataExtractionMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTPolarizedDataExtractionMode_first_get", _wrap_pairstringTPolarizedDataExtractionMode_first_get, METH_O, NULL},
	 { "pairstringTPolarizedDataExtractionMode_second_set", _wrap_pairstringTPolarizedDataExtractionMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTPolarizedDataExtractionMode_second_get", _wrap_pairstringTPolarizedDataExtractionMode_second_get, METH_O, NULL},
	 { "delete_pairstringTPolarizedDataExtractionMode", _wrap_delete_pairstringTPolarizedDataExtractionMode, METH_O, NULL},
	 { "pairstringTPolarizedDataExtractionMode_swigregister", pairstringTPolarizedDataExtractionMode_swigregister, METH_O, NULL},
	 { "pairstringTPolarizedDataExtractionMode_swiginit", pairstringTPolarizedDataExtractionMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIPolarizedDataExtractionInterpolationMode", _wrap_new_PropertyIPolarizedDataExtractionInterpolationMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValues", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_getMaxValue", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_getMinValue", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_getStepWidth", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_read", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_write", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIPolarizedDataExtractionInterpolationMode", _wrap_delete_PropertyIPolarizedDataExtractionInterpolationMode, METH_O, NULL},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_swigregister", PropertyIPolarizedDataExtractionInterpolationMode_swigregister, METH_O, NULL},
	 { "PropertyIPolarizedDataExtractionInterpolationMode_swiginit", PropertyIPolarizedDataExtractionInterpolationMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTPolarizedDataExtractionInterpolationMode", _wrap_new_pairstringTPolarizedDataExtractionInterpolationMode, METH_VARARGS, NULL},
	 { "pairstringTPolarizedDataExtractionInterpolationMode_first_set", _wrap_pairstringTPolarizedDataExtractionInterpolationMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTPolarizedDataExtractionInterpolationMode_first_get", _wrap_pairstringTPolarizedDataExtractionInterpolationMode_first_get, METH_O, NULL},
	 { "pairstringTPolarizedDataExtractionInterpolationMode_second_set", _wrap_pairstringTPolarizedDataExtractionInterpolationMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTPolarizedDataExtractionInterpolationMode_second_get", _wrap_pairstringTPolarizedDataExtractionInterpolationMode_second_get, METH_O, NULL},
	 { "delete_pairstringTPolarizedDataExtractionInterpolationMode", _wrap_delete_pairstringTPolarizedDataExtractionInterpolationMode, METH_O, NULL},
	 { "pairstringTPolarizedDataExtractionInterpolationMode_swigregister", pairstringTPolarizedDataExtractionInterpolationMode_swigregister, METH_O, NULL},
	 { "pairstringTPolarizedDataExtractionInterpolationMode_swiginit", pairstringTPolarizedDataExtractionInterpolationMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIPulseStartTrigger", _wrap_new_PropertyIPulseStartTrigger, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIPulseStartTrigger_getTranslationDict", _wrap_PropertyIPulseStartTrigger_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIPulseStartTrigger_getTranslationDictString", _wrap_PropertyIPulseStartTrigger_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIPulseStartTrigger_getTranslationDictValue", _wrap_PropertyIPulseStartTrigger_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIPulseStartTrigger_getTranslationDictStrings", _wrap_PropertyIPulseStartTrigger_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIPulseStartTrigger_getTranslationDictValues", _wrap_PropertyIPulseStartTrigger_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIPulseStartTrigger_getMaxValue", _wrap_PropertyIPulseStartTrigger_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIPulseStartTrigger_getMinValue", _wrap_PropertyIPulseStartTrigger_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIPulseStartTrigger_getStepWidth", _wrap_PropertyIPulseStartTrigger_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIPulseStartTrigger_read", _wrap_PropertyIPulseStartTrigger_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIPulseStartTrigger_write", _wrap_PropertyIPulseStartTrigger_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIPulseStartTrigger", _wrap_delete_PropertyIPulseStartTrigger, METH_O, NULL},
	 { "PropertyIPulseStartTrigger_swigregister", PropertyIPulseStartTrigger_swigregister, METH_O, NULL},
	 { "PropertyIPulseStartTrigger_swiginit", PropertyIPulseStartTrigger_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTPulseStartTrigger", _wrap_new_pairstringTPulseStartTrigger, METH_VARARGS, NULL},
	 { "pairstringTPulseStartTrigger_first_set", _wrap_pairstringTPulseStartTrigger_first_set, METH_VARARGS, NULL},
	 { "pairstringTPulseStartTrigger_first_get", _wrap_pairstringTPulseStartTrigger_first_get, METH_O, NULL},
	 { "pairstringTPulseStartTrigger_second_set", _wrap_pairstringTPulseStartTrigger_second_set, METH_VARARGS, NULL},
	 { "pairstringTPulseStartTrigger_second_get", _wrap_pairstringTPulseStartTrigger_second_get, METH_O, NULL},
	 { "delete_pairstringTPulseStartTrigger", _wrap_delete_pairstringTPulseStartTrigger, METH_O, NULL},
	 { "pairstringTPulseStartTrigger_swigregister", pairstringTPulseStartTrigger_swigregister, METH_O, NULL},
	 { "pairstringTPulseStartTrigger_swiginit", pairstringTPulseStartTrigger_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIRequestResult", _wrap_new_PropertyIRequestResult, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIRequestResult_getTranslationDict", _wrap_PropertyIRequestResult_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRequestResult > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIRequestResult_getTranslationDictString", _wrap_PropertyIRequestResult_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRequestResult_getTranslationDictValue", _wrap_PropertyIRequestResult_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRequestResult_getTranslationDictStrings", _wrap_PropertyIRequestResult_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRequestResult_getTranslationDictValues", _wrap_PropertyIRequestResult_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRequestResult_getMaxValue", _wrap_PropertyIRequestResult_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRequestResult_getMinValue", _wrap_PropertyIRequestResult_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRequestResult_getStepWidth", _wrap_PropertyIRequestResult_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRequestResult_read", _wrap_PropertyIRequestResult_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIRequestResult_write", _wrap_PropertyIRequestResult_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIRequestResult", _wrap_delete_PropertyIRequestResult, METH_O, NULL},
	 { "PropertyIRequestResult_swigregister", PropertyIRequestResult_swigregister, METH_O, NULL},
	 { "PropertyIRequestResult_swiginit", PropertyIRequestResult_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTRequestResult", _wrap_new_pairstringTRequestResult, METH_VARARGS, NULL},
	 { "pairstringTRequestResult_first_set", _wrap_pairstringTRequestResult_first_set, METH_VARARGS, NULL},
	 { "pairstringTRequestResult_first_get", _wrap_pairstringTRequestResult_first_get, METH_O, NULL},
	 { "pairstringTRequestResult_second_set", _wrap_pairstringTRequestResult_second_set, METH_VARARGS, NULL},
	 { "pairstringTRequestResult_second_get", _wrap_pairstringTRequestResult_second_get, METH_O, NULL},
	 { "delete_pairstringTRequestResult", _wrap_delete_pairstringTRequestResult, METH_O, NULL},
	 { "pairstringTRequestResult_swigregister", pairstringTRequestResult_swigregister, METH_O, NULL},
	 { "pairstringTRequestResult_swiginit", pairstringTRequestResult_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIRequestState", _wrap_new_PropertyIRequestState, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIRequestState_getTranslationDict", _wrap_PropertyIRequestState_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestState >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRequestState > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIRequestState_getTranslationDictString", _wrap_PropertyIRequestState_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRequestState_getTranslationDictValue", _wrap_PropertyIRequestState_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRequestState_getTranslationDictStrings", _wrap_PropertyIRequestState_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRequestState_getTranslationDictValues", _wrap_PropertyIRequestState_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRequestState_getMaxValue", _wrap_PropertyIRequestState_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRequestState_getMinValue", _wrap_PropertyIRequestState_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRequestState_getStepWidth", _wrap_PropertyIRequestState_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRequestState_read", _wrap_PropertyIRequestState_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIRequestState_write", _wrap_PropertyIRequestState_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIRequestState", _wrap_delete_PropertyIRequestState, METH_O, NULL},
	 { "PropertyIRequestState_swigregister", PropertyIRequestState_swigregister, METH_O, NULL},
	 { "PropertyIRequestState_swiginit", PropertyIRequestState_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTRequestState", _wrap_new_pairstringTRequestState, METH_VARARGS, NULL},
	 { "pairstringTRequestState_first_set", _wrap_pairstringTRequestState_first_set, METH_VARARGS, NULL},
	 { "pairstringTRequestState_first_get", _wrap_pairstringTRequestState_first_get, METH_O, NULL},
	 { "pairstringTRequestState_second_set", _wrap_pairstringTRequestState_second_set, METH_VARARGS, NULL},
	 { "pairstringTRequestState_second_get", _wrap_pairstringTRequestState_second_get, METH_O, NULL},
	 { "delete_pairstringTRequestState", _wrap_delete_pairstringTRequestState, METH_O, NULL},
	 { "pairstringTRequestState_swigregister", pairstringTRequestState_swigregister, METH_O, NULL},
	 { "pairstringTRequestState_swiginit", pairstringTRequestState_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIRTCtrlModes", _wrap_new_PropertyIRTCtrlModes, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIRTCtrlModes_getTranslationDict", _wrap_PropertyIRTCtrlModes_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIRTCtrlModes_getTranslationDictString", _wrap_PropertyIRTCtrlModes_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRTCtrlModes_getTranslationDictValue", _wrap_PropertyIRTCtrlModes_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRTCtrlModes_getTranslationDictStrings", _wrap_PropertyIRTCtrlModes_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRTCtrlModes_getTranslationDictValues", _wrap_PropertyIRTCtrlModes_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRTCtrlModes_getMaxValue", _wrap_PropertyIRTCtrlModes_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRTCtrlModes_getMinValue", _wrap_PropertyIRTCtrlModes_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRTCtrlModes_getStepWidth", _wrap_PropertyIRTCtrlModes_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRTCtrlModes_read", _wrap_PropertyIRTCtrlModes_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIRTCtrlModes_write", _wrap_PropertyIRTCtrlModes_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIRTCtrlModes", _wrap_delete_PropertyIRTCtrlModes, METH_O, NULL},
	 { "PropertyIRTCtrlModes_swigregister", PropertyIRTCtrlModes_swigregister, METH_O, NULL},
	 { "PropertyIRTCtrlModes_swiginit", PropertyIRTCtrlModes_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTRTCtrlModes", _wrap_new_pairstringTRTCtrlModes, METH_VARARGS, NULL},
	 { "pairstringTRTCtrlModes_first_set", _wrap_pairstringTRTCtrlModes_first_set, METH_VARARGS, NULL},
	 { "pairstringTRTCtrlModes_first_get", _wrap_pairstringTRTCtrlModes_first_get, METH_O, NULL},
	 { "pairstringTRTCtrlModes_second_set", _wrap_pairstringTRTCtrlModes_second_set, METH_VARARGS, NULL},
	 { "pairstringTRTCtrlModes_second_get", _wrap_pairstringTRTCtrlModes_second_get, METH_O, NULL},
	 { "delete_pairstringTRTCtrlModes", _wrap_delete_pairstringTRTCtrlModes, METH_O, NULL},
	 { "pairstringTRTCtrlModes_swigregister", pairstringTRTCtrlModes_swigregister, METH_O, NULL},
	 { "pairstringTRTCtrlModes_swiginit", pairstringTRTCtrlModes_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIRTProgOpCodes", _wrap_new_PropertyIRTProgOpCodes, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIRTProgOpCodes_getTranslationDict", _wrap_PropertyIRTProgOpCodes_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIRTProgOpCodes_getTranslationDictString", _wrap_PropertyIRTProgOpCodes_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRTProgOpCodes_getTranslationDictValue", _wrap_PropertyIRTProgOpCodes_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIRTProgOpCodes_getTranslationDictStrings", _wrap_PropertyIRTProgOpCodes_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRTProgOpCodes_getTranslationDictValues", _wrap_PropertyIRTProgOpCodes_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIRTProgOpCodes_getMaxValue", _wrap_PropertyIRTProgOpCodes_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRTProgOpCodes_getMinValue", _wrap_PropertyIRTProgOpCodes_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRTProgOpCodes_getStepWidth", _wrap_PropertyIRTProgOpCodes_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIRTProgOpCodes_read", _wrap_PropertyIRTProgOpCodes_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIRTProgOpCodes_write", _wrap_PropertyIRTProgOpCodes_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIRTProgOpCodes", _wrap_delete_PropertyIRTProgOpCodes, METH_O, NULL},
	 { "PropertyIRTProgOpCodes_swigregister", PropertyIRTProgOpCodes_swigregister, METH_O, NULL},
	 { "PropertyIRTProgOpCodes_swiginit", PropertyIRTProgOpCodes_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTRTProgOpCodes", _wrap_new_pairstringTRTProgOpCodes, METH_VARARGS, NULL},
	 { "pairstringTRTProgOpCodes_first_set", _wrap_pairstringTRTProgOpCodes_first_set, METH_VARARGS, NULL},
	 { "pairstringTRTProgOpCodes_first_get", _wrap_pairstringTRTProgOpCodes_first_get, METH_O, NULL},
	 { "pairstringTRTProgOpCodes_second_set", _wrap_pairstringTRTProgOpCodes_second_set, METH_VARARGS, NULL},
	 { "pairstringTRTProgOpCodes_second_get", _wrap_pairstringTRTProgOpCodes_second_get, METH_O, NULL},
	 { "delete_pairstringTRTProgOpCodes", _wrap_delete_pairstringTRTProgOpCodes, METH_O, NULL},
	 { "pairstringTRTProgOpCodes_swigregister", pairstringTRTProgOpCodes_swigregister, METH_O, NULL},
	 { "pairstringTRTProgOpCodes_swiginit", pairstringTRTProgOpCodes_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIScalerMode", _wrap_new_PropertyIScalerMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIScalerMode_getTranslationDict", _wrap_PropertyIScalerMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScalerMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIScalerMode_getTranslationDictString", _wrap_PropertyIScalerMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIScalerMode_getTranslationDictValue", _wrap_PropertyIScalerMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIScalerMode_getTranslationDictStrings", _wrap_PropertyIScalerMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIScalerMode_getTranslationDictValues", _wrap_PropertyIScalerMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIScalerMode_getMaxValue", _wrap_PropertyIScalerMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScalerMode_getMinValue", _wrap_PropertyIScalerMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScalerMode_getStepWidth", _wrap_PropertyIScalerMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScalerMode_read", _wrap_PropertyIScalerMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIScalerMode_write", _wrap_PropertyIScalerMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIScalerMode", _wrap_delete_PropertyIScalerMode, METH_O, NULL},
	 { "PropertyIScalerMode_swigregister", PropertyIScalerMode_swigregister, METH_O, NULL},
	 { "PropertyIScalerMode_swiginit", PropertyIScalerMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTScalerMode", _wrap_new_pairstringTScalerMode, METH_VARARGS, NULL},
	 { "pairstringTScalerMode_first_set", _wrap_pairstringTScalerMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTScalerMode_first_get", _wrap_pairstringTScalerMode_first_get, METH_O, NULL},
	 { "pairstringTScalerMode_second_set", _wrap_pairstringTScalerMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTScalerMode_second_get", _wrap_pairstringTScalerMode_second_get, METH_O, NULL},
	 { "delete_pairstringTScalerMode", _wrap_delete_pairstringTScalerMode, METH_O, NULL},
	 { "pairstringTScalerMode_swigregister", pairstringTScalerMode_swigregister, METH_O, NULL},
	 { "pairstringTScalerMode_swiginit", pairstringTScalerMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIScalerInterpolationMode", _wrap_new_PropertyIScalerInterpolationMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIScalerInterpolationMode_getTranslationDict", _wrap_PropertyIScalerInterpolationMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIScalerInterpolationMode_getTranslationDictString", _wrap_PropertyIScalerInterpolationMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIScalerInterpolationMode_getTranslationDictValue", _wrap_PropertyIScalerInterpolationMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIScalerInterpolationMode_getTranslationDictStrings", _wrap_PropertyIScalerInterpolationMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIScalerInterpolationMode_getTranslationDictValues", _wrap_PropertyIScalerInterpolationMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIScalerInterpolationMode_getMaxValue", _wrap_PropertyIScalerInterpolationMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScalerInterpolationMode_getMinValue", _wrap_PropertyIScalerInterpolationMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScalerInterpolationMode_getStepWidth", _wrap_PropertyIScalerInterpolationMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScalerInterpolationMode_read", _wrap_PropertyIScalerInterpolationMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIScalerInterpolationMode_write", _wrap_PropertyIScalerInterpolationMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIScalerInterpolationMode", _wrap_delete_PropertyIScalerInterpolationMode, METH_O, NULL},
	 { "PropertyIScalerInterpolationMode_swigregister", PropertyIScalerInterpolationMode_swigregister, METH_O, NULL},
	 { "PropertyIScalerInterpolationMode_swiginit", PropertyIScalerInterpolationMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTScalerInterpolationMode", _wrap_new_pairstringTScalerInterpolationMode, METH_VARARGS, NULL},
	 { "pairstringTScalerInterpolationMode_first_set", _wrap_pairstringTScalerInterpolationMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTScalerInterpolationMode_first_get", _wrap_pairstringTScalerInterpolationMode_first_get, METH_O, NULL},
	 { "pairstringTScalerInterpolationMode_second_set", _wrap_pairstringTScalerInterpolationMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTScalerInterpolationMode_second_get", _wrap_pairstringTScalerInterpolationMode_second_get, METH_O, NULL},
	 { "delete_pairstringTScalerInterpolationMode", _wrap_delete_pairstringTScalerInterpolationMode, METH_O, NULL},
	 { "pairstringTScalerInterpolationMode_swigregister", pairstringTScalerInterpolationMode_swigregister, METH_O, NULL},
	 { "pairstringTScalerInterpolationMode_swiginit", pairstringTScalerInterpolationMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIScanClock", _wrap_new_PropertyIScanClock, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIScanClock_getTranslationDict", _wrap_PropertyIScanClock_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TScanClock >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScanClock > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIScanClock_getTranslationDictString", _wrap_PropertyIScanClock_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIScanClock_getTranslationDictValue", _wrap_PropertyIScanClock_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIScanClock_getTranslationDictStrings", _wrap_PropertyIScanClock_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIScanClock_getTranslationDictValues", _wrap_PropertyIScanClock_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIScanClock_getMaxValue", _wrap_PropertyIScanClock_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScanClock_getMinValue", _wrap_PropertyIScanClock_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScanClock_getStepWidth", _wrap_PropertyIScanClock_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScanClock_read", _wrap_PropertyIScanClock_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIScanClock_write", _wrap_PropertyIScanClock_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIScanClock", _wrap_delete_PropertyIScanClock, METH_O, NULL},
	 { "PropertyIScanClock_swigregister", PropertyIScanClock_swigregister, METH_O, NULL},
	 { "PropertyIScanClock_swiginit", PropertyIScanClock_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTScanClock", _wrap_new_pairstringTScanClock, METH_VARARGS, NULL},
	 { "pairstringTScanClock_first_set", _wrap_pairstringTScanClock_first_set, METH_VARARGS, NULL},
	 { "pairstringTScanClock_first_get", _wrap_pairstringTScanClock_first_get, METH_O, NULL},
	 { "pairstringTScanClock_second_set", _wrap_pairstringTScanClock_second_set, METH_VARARGS, NULL},
	 { "pairstringTScanClock_second_get", _wrap_pairstringTScanClock_second_get, METH_O, NULL},
	 { "delete_pairstringTScanClock", _wrap_delete_pairstringTScanClock, METH_O, NULL},
	 { "pairstringTScanClock_swigregister", pairstringTScanClock_swigregister, METH_O, NULL},
	 { "pairstringTScanClock_swiginit", pairstringTScanClock_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIScanStandard", _wrap_new_PropertyIScanStandard, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIScanStandard_getTranslationDict", _wrap_PropertyIScanStandard_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TScanStandard >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScanStandard > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIScanStandard_getTranslationDictString", _wrap_PropertyIScanStandard_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIScanStandard_getTranslationDictValue", _wrap_PropertyIScanStandard_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIScanStandard_getTranslationDictStrings", _wrap_PropertyIScanStandard_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIScanStandard_getTranslationDictValues", _wrap_PropertyIScanStandard_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIScanStandard_getMaxValue", _wrap_PropertyIScanStandard_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScanStandard_getMinValue", _wrap_PropertyIScanStandard_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScanStandard_getStepWidth", _wrap_PropertyIScanStandard_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIScanStandard_read", _wrap_PropertyIScanStandard_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIScanStandard_write", _wrap_PropertyIScanStandard_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIScanStandard", _wrap_delete_PropertyIScanStandard, METH_O, NULL},
	 { "PropertyIScanStandard_swigregister", PropertyIScanStandard_swigregister, METH_O, NULL},
	 { "PropertyIScanStandard_swiginit", PropertyIScanStandard_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTScanStandard", _wrap_new_pairstringTScanStandard, METH_VARARGS, NULL},
	 { "pairstringTScanStandard_first_set", _wrap_pairstringTScanStandard_first_set, METH_VARARGS, NULL},
	 { "pairstringTScanStandard_first_get", _wrap_pairstringTScanStandard_first_get, METH_O, NULL},
	 { "pairstringTScanStandard_second_set", _wrap_pairstringTScanStandard_second_set, METH_VARARGS, NULL},
	 { "pairstringTScanStandard_second_get", _wrap_pairstringTScanStandard_second_get, METH_O, NULL},
	 { "delete_pairstringTScanStandard", _wrap_delete_pairstringTScanStandard, METH_O, NULL},
	 { "pairstringTScanStandard_swigregister", pairstringTScanStandard_swigregister, METH_O, NULL},
	 { "pairstringTScanStandard_swiginit", pairstringTScanStandard_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyITriggerMoment", _wrap_new_PropertyITriggerMoment, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyITriggerMoment_getTranslationDict", _wrap_PropertyITriggerMoment_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyITriggerMoment_getTranslationDictString", _wrap_PropertyITriggerMoment_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyITriggerMoment_getTranslationDictValue", _wrap_PropertyITriggerMoment_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyITriggerMoment_getTranslationDictStrings", _wrap_PropertyITriggerMoment_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyITriggerMoment_getTranslationDictValues", _wrap_PropertyITriggerMoment_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyITriggerMoment_getMaxValue", _wrap_PropertyITriggerMoment_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyITriggerMoment_getMinValue", _wrap_PropertyITriggerMoment_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyITriggerMoment_getStepWidth", _wrap_PropertyITriggerMoment_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyITriggerMoment_read", _wrap_PropertyITriggerMoment_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyITriggerMoment_write", _wrap_PropertyITriggerMoment_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyITriggerMoment", _wrap_delete_PropertyITriggerMoment, METH_O, NULL},
	 { "PropertyITriggerMoment_swigregister", PropertyITriggerMoment_swigregister, METH_O, NULL},
	 { "PropertyITriggerMoment_swiginit", PropertyITriggerMoment_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTTriggerMoment", _wrap_new_pairstringTTriggerMoment, METH_VARARGS, NULL},
	 { "pairstringTTriggerMoment_first_set", _wrap_pairstringTTriggerMoment_first_set, METH_VARARGS, NULL},
	 { "pairstringTTriggerMoment_first_get", _wrap_pairstringTTriggerMoment_first_get, METH_O, NULL},
	 { "pairstringTTriggerMoment_second_set", _wrap_pairstringTTriggerMoment_second_set, METH_VARARGS, NULL},
	 { "pairstringTTriggerMoment_second_get", _wrap_pairstringTTriggerMoment_second_get, METH_O, NULL},
	 { "delete_pairstringTTriggerMoment", _wrap_delete_pairstringTTriggerMoment, METH_O, NULL},
	 { "pairstringTTriggerMoment_swigregister", pairstringTTriggerMoment_swigregister, METH_O, NULL},
	 { "pairstringTTriggerMoment_swiginit", pairstringTTriggerMoment_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIUserDataAccessRight", _wrap_new_PropertyIUserDataAccessRight, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIUserDataAccessRight_getTranslationDict", _wrap_PropertyIUserDataAccessRight_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIUserDataAccessRight_getTranslationDictString", _wrap_PropertyIUserDataAccessRight_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIUserDataAccessRight_getTranslationDictValue", _wrap_PropertyIUserDataAccessRight_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIUserDataAccessRight_getTranslationDictStrings", _wrap_PropertyIUserDataAccessRight_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIUserDataAccessRight_getTranslationDictValues", _wrap_PropertyIUserDataAccessRight_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIUserDataAccessRight_getMaxValue", _wrap_PropertyIUserDataAccessRight_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIUserDataAccessRight_getMinValue", _wrap_PropertyIUserDataAccessRight_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIUserDataAccessRight_getStepWidth", _wrap_PropertyIUserDataAccessRight_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIUserDataAccessRight_read", _wrap_PropertyIUserDataAccessRight_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIUserDataAccessRight_write", _wrap_PropertyIUserDataAccessRight_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIUserDataAccessRight", _wrap_delete_PropertyIUserDataAccessRight, METH_O, NULL},
	 { "PropertyIUserDataAccessRight_swigregister", PropertyIUserDataAccessRight_swigregister, METH_O, NULL},
	 { "PropertyIUserDataAccessRight_swiginit", PropertyIUserDataAccessRight_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTUserDataAccessRight", _wrap_new_pairstringTUserDataAccessRight, METH_VARARGS, NULL},
	 { "pairstringTUserDataAccessRight_first_set", _wrap_pairstringTUserDataAccessRight_first_set, METH_VARARGS, NULL},
	 { "pairstringTUserDataAccessRight_first_get", _wrap_pairstringTUserDataAccessRight_first_get, METH_O, NULL},
	 { "pairstringTUserDataAccessRight_second_set", _wrap_pairstringTUserDataAccessRight_second_set, METH_VARARGS, NULL},
	 { "pairstringTUserDataAccessRight_second_get", _wrap_pairstringTUserDataAccessRight_second_get, METH_O, NULL},
	 { "delete_pairstringTUserDataAccessRight", _wrap_delete_pairstringTUserDataAccessRight, METH_O, NULL},
	 { "pairstringTUserDataAccessRight_swigregister", pairstringTUserDataAccessRight_swigregister, METH_O, NULL},
	 { "pairstringTUserDataAccessRight_swiginit", pairstringTUserDataAccessRight_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIUserDataReconnectBehaviour", _wrap_new_PropertyIUserDataReconnectBehaviour, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_getTranslationDict", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_getTranslationDictString", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_getTranslationDictValue", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_getTranslationDictStrings", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_getTranslationDictValues", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_getMaxValue", _wrap_PropertyIUserDataReconnectBehaviour_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_getMinValue", _wrap_PropertyIUserDataReconnectBehaviour_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_getStepWidth", _wrap_PropertyIUserDataReconnectBehaviour_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_read", _wrap_PropertyIUserDataReconnectBehaviour_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIUserDataReconnectBehaviour_write", _wrap_PropertyIUserDataReconnectBehaviour_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIUserDataReconnectBehaviour", _wrap_delete_PropertyIUserDataReconnectBehaviour, METH_O, NULL},
	 { "PropertyIUserDataReconnectBehaviour_swigregister", PropertyIUserDataReconnectBehaviour_swigregister, METH_O, NULL},
	 { "PropertyIUserDataReconnectBehaviour_swiginit", PropertyIUserDataReconnectBehaviour_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTUserDataReconnectBehaviour", _wrap_new_pairstringTUserDataReconnectBehaviour, METH_VARARGS, NULL},
	 { "pairstringTUserDataReconnectBehaviour_first_set", _wrap_pairstringTUserDataReconnectBehaviour_first_set, METH_VARARGS, NULL},
	 { "pairstringTUserDataReconnectBehaviour_first_get", _wrap_pairstringTUserDataReconnectBehaviour_first_get, METH_O, NULL},
	 { "pairstringTUserDataReconnectBehaviour_second_set", _wrap_pairstringTUserDataReconnectBehaviour_second_set, METH_VARARGS, NULL},
	 { "pairstringTUserDataReconnectBehaviour_second_get", _wrap_pairstringTUserDataReconnectBehaviour_second_get, METH_O, NULL},
	 { "delete_pairstringTUserDataReconnectBehaviour", _wrap_delete_pairstringTUserDataReconnectBehaviour, METH_O, NULL},
	 { "pairstringTUserDataReconnectBehaviour_swigregister", pairstringTUserDataReconnectBehaviour_swigregister, METH_O, NULL},
	 { "pairstringTUserDataReconnectBehaviour_swiginit", pairstringTUserDataReconnectBehaviour_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIVideoStandard", _wrap_new_PropertyIVideoStandard, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIVideoStandard_getTranslationDict", _wrap_PropertyIVideoStandard_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TVideoStandard >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIVideoStandard_getTranslationDictString", _wrap_PropertyIVideoStandard_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIVideoStandard_getTranslationDictValue", _wrap_PropertyIVideoStandard_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIVideoStandard_getTranslationDictStrings", _wrap_PropertyIVideoStandard_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIVideoStandard_getTranslationDictValues", _wrap_PropertyIVideoStandard_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIVideoStandard_getMaxValue", _wrap_PropertyIVideoStandard_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIVideoStandard_getMinValue", _wrap_PropertyIVideoStandard_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIVideoStandard_getStepWidth", _wrap_PropertyIVideoStandard_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIVideoStandard_read", _wrap_PropertyIVideoStandard_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIVideoStandard_write", _wrap_PropertyIVideoStandard_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIVideoStandard", _wrap_delete_PropertyIVideoStandard, METH_O, NULL},
	 { "PropertyIVideoStandard_swigregister", PropertyIVideoStandard_swigregister, METH_O, NULL},
	 { "PropertyIVideoStandard_swiginit", PropertyIVideoStandard_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTVideoStandard", _wrap_new_pairstringTVideoStandard, METH_VARARGS, NULL},
	 { "pairstringTVideoStandard_first_set", _wrap_pairstringTVideoStandard_first_set, METH_VARARGS, NULL},
	 { "pairstringTVideoStandard_first_get", _wrap_pairstringTVideoStandard_first_get, METH_O, NULL},
	 { "pairstringTVideoStandard_second_set", _wrap_pairstringTVideoStandard_second_set, METH_VARARGS, NULL},
	 { "pairstringTVideoStandard_second_get", _wrap_pairstringTVideoStandard_second_get, METH_O, NULL},
	 { "delete_pairstringTVideoStandard", _wrap_delete_pairstringTVideoStandard, METH_O, NULL},
	 { "pairstringTVideoStandard_swigregister", pairstringTVideoStandard_swigregister, METH_O, NULL},
	 { "pairstringTVideoStandard_swiginit", pairstringTVideoStandard_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIVirtualDeviceImageType", _wrap_new_PropertyIVirtualDeviceImageType, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIVirtualDeviceImageType_getTranslationDict", _wrap_PropertyIVirtualDeviceImageType_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIVirtualDeviceImageType_getTranslationDictString", _wrap_PropertyIVirtualDeviceImageType_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIVirtualDeviceImageType_getTranslationDictValue", _wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIVirtualDeviceImageType_getTranslationDictStrings", _wrap_PropertyIVirtualDeviceImageType_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIVirtualDeviceImageType_getTranslationDictValues", _wrap_PropertyIVirtualDeviceImageType_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIVirtualDeviceImageType_getMaxValue", _wrap_PropertyIVirtualDeviceImageType_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIVirtualDeviceImageType_getMinValue", _wrap_PropertyIVirtualDeviceImageType_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIVirtualDeviceImageType_getStepWidth", _wrap_PropertyIVirtualDeviceImageType_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIVirtualDeviceImageType_read", _wrap_PropertyIVirtualDeviceImageType_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIVirtualDeviceImageType_write", _wrap_PropertyIVirtualDeviceImageType_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIVirtualDeviceImageType", _wrap_delete_PropertyIVirtualDeviceImageType, METH_O, NULL},
	 { "PropertyIVirtualDeviceImageType_swigregister", PropertyIVirtualDeviceImageType_swigregister, METH_O, NULL},
	 { "PropertyIVirtualDeviceImageType_swiginit", PropertyIVirtualDeviceImageType_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTVirtualDeviceImageType", _wrap_new_pairstringTVirtualDeviceImageType, METH_VARARGS, NULL},
	 { "pairstringTVirtualDeviceImageType_first_set", _wrap_pairstringTVirtualDeviceImageType_first_set, METH_VARARGS, NULL},
	 { "pairstringTVirtualDeviceImageType_first_get", _wrap_pairstringTVirtualDeviceImageType_first_get, METH_O, NULL},
	 { "pairstringTVirtualDeviceImageType_second_set", _wrap_pairstringTVirtualDeviceImageType_second_set, METH_VARARGS, NULL},
	 { "pairstringTVirtualDeviceImageType_second_get", _wrap_pairstringTVirtualDeviceImageType_second_get, METH_O, NULL},
	 { "delete_pairstringTVirtualDeviceImageType", _wrap_delete_pairstringTVirtualDeviceImageType, METH_O, NULL},
	 { "pairstringTVirtualDeviceImageType_swigregister", pairstringTVirtualDeviceImageType_swigregister, METH_O, NULL},
	 { "pairstringTVirtualDeviceImageType_swiginit", pairstringTVirtualDeviceImageType_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIVirtualDeviceTestMode", _wrap_new_PropertyIVirtualDeviceTestMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_getTranslationDict", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_getTranslationDictString", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_getTranslationDictValue", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_getTranslationDictStrings", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_getTranslationDictValues", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_getMaxValue", _wrap_PropertyIVirtualDeviceTestMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_getMinValue", _wrap_PropertyIVirtualDeviceTestMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_getStepWidth", _wrap_PropertyIVirtualDeviceTestMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_read", _wrap_PropertyIVirtualDeviceTestMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIVirtualDeviceTestMode_write", _wrap_PropertyIVirtualDeviceTestMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIVirtualDeviceTestMode", _wrap_delete_PropertyIVirtualDeviceTestMode, METH_O, NULL},
	 { "PropertyIVirtualDeviceTestMode_swigregister", PropertyIVirtualDeviceTestMode_swigregister, METH_O, NULL},
	 { "PropertyIVirtualDeviceTestMode_swiginit", PropertyIVirtualDeviceTestMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTVirtualDeviceTestMode", _wrap_new_pairstringTVirtualDeviceTestMode, METH_VARARGS, NULL},
	 { "pairstringTVirtualDeviceTestMode_first_set", _wrap_pairstringTVirtualDeviceTestMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTVirtualDeviceTestMode_first_get", _wrap_pairstringTVirtualDeviceTestMode_first_get, METH_O, NULL},
	 { "pairstringTVirtualDeviceTestMode_second_set", _wrap_pairstringTVirtualDeviceTestMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTVirtualDeviceTestMode_second_get", _wrap_pairstringTVirtualDeviceTestMode_second_get, METH_O, NULL},
	 { "delete_pairstringTVirtualDeviceTestMode", _wrap_delete_pairstringTVirtualDeviceTestMode, METH_O, NULL},
	 { "pairstringTVirtualDeviceTestMode_swigregister", pairstringTVirtualDeviceTestMode_swigregister, METH_O, NULL},
	 { "pairstringTVirtualDeviceTestMode_swiginit", pairstringTVirtualDeviceTestMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIWhiteBalanceCalibrationMode", _wrap_new_PropertyIWhiteBalanceCalibrationMode, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_getTranslationDict", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_getTranslationDictString", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_getTranslationDictValues", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_getMaxValue", _wrap_PropertyIWhiteBalanceCalibrationMode_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_getMinValue", _wrap_PropertyIWhiteBalanceCalibrationMode_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_getStepWidth", _wrap_PropertyIWhiteBalanceCalibrationMode_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_read", _wrap_PropertyIWhiteBalanceCalibrationMode_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIWhiteBalanceCalibrationMode_write", _wrap_PropertyIWhiteBalanceCalibrationMode_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIWhiteBalanceCalibrationMode", _wrap_delete_PropertyIWhiteBalanceCalibrationMode, METH_O, NULL},
	 { "PropertyIWhiteBalanceCalibrationMode_swigregister", PropertyIWhiteBalanceCalibrationMode_swigregister, METH_O, NULL},
	 { "PropertyIWhiteBalanceCalibrationMode_swiginit", PropertyIWhiteBalanceCalibrationMode_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTWhiteBalanceCalibrationMode", _wrap_new_pairstringTWhiteBalanceCalibrationMode, METH_VARARGS, NULL},
	 { "pairstringTWhiteBalanceCalibrationMode_first_set", _wrap_pairstringTWhiteBalanceCalibrationMode_first_set, METH_VARARGS, NULL},
	 { "pairstringTWhiteBalanceCalibrationMode_first_get", _wrap_pairstringTWhiteBalanceCalibrationMode_first_get, METH_O, NULL},
	 { "pairstringTWhiteBalanceCalibrationMode_second_set", _wrap_pairstringTWhiteBalanceCalibrationMode_second_set, METH_VARARGS, NULL},
	 { "pairstringTWhiteBalanceCalibrationMode_second_get", _wrap_pairstringTWhiteBalanceCalibrationMode_second_get, METH_O, NULL},
	 { "delete_pairstringTWhiteBalanceCalibrationMode", _wrap_delete_pairstringTWhiteBalanceCalibrationMode, METH_O, NULL},
	 { "pairstringTWhiteBalanceCalibrationMode_swigregister", pairstringTWhiteBalanceCalibrationMode_swigregister, METH_O, NULL},
	 { "pairstringTWhiteBalanceCalibrationMode_swiginit", pairstringTWhiteBalanceCalibrationMode_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyIWhiteBalanceParameter", _wrap_new_PropertyIWhiteBalanceParameter, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to an integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from\n"
		""},
	 { "PropertyIWhiteBalanceParameter_getTranslationDict", _wrap_PropertyIWhiteBalanceParameter_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyIWhiteBalanceParameter_getTranslationDictString", _wrap_PropertyIWhiteBalanceParameter_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIWhiteBalanceParameter_getTranslationDictValue", _wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyIWhiteBalanceParameter_getTranslationDictStrings", _wrap_PropertyIWhiteBalanceParameter_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIWhiteBalanceParameter_getTranslationDictValues", _wrap_PropertyIWhiteBalanceParameter_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyIWhiteBalanceParameter_getMaxValue", _wrap_PropertyIWhiteBalanceParameter_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIWhiteBalanceParameter_getMinValue", _wrap_PropertyIWhiteBalanceParameter_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIWhiteBalanceParameter_getStepWidth", _wrap_PropertyIWhiteBalanceParameter_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyIWhiteBalanceParameter_read", _wrap_PropertyIWhiteBalanceParameter_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyIWhiteBalanceParameter_write", _wrap_PropertyIWhiteBalanceParameter_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyIWhiteBalanceParameter", _wrap_delete_PropertyIWhiteBalanceParameter, METH_O, NULL},
	 { "PropertyIWhiteBalanceParameter_swigregister", PropertyIWhiteBalanceParameter_swigregister, METH_O, NULL},
	 { "PropertyIWhiteBalanceParameter_swiginit", PropertyIWhiteBalanceParameter_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTWhiteBalanceParameter", _wrap_new_pairstringTWhiteBalanceParameter, METH_VARARGS, NULL},
	 { "pairstringTWhiteBalanceParameter_first_set", _wrap_pairstringTWhiteBalanceParameter_first_set, METH_VARARGS, NULL},
	 { "pairstringTWhiteBalanceParameter_first_get", _wrap_pairstringTWhiteBalanceParameter_first_get, METH_O, NULL},
	 { "pairstringTWhiteBalanceParameter_second_set", _wrap_pairstringTWhiteBalanceParameter_second_set, METH_VARARGS, NULL},
	 { "pairstringTWhiteBalanceParameter_second_get", _wrap_pairstringTWhiteBalanceParameter_second_get, METH_O, NULL},
	 { "delete_pairstringTWhiteBalanceParameter", _wrap_delete_pairstringTWhiteBalanceParameter, METH_O, NULL},
	 { "pairstringTWhiteBalanceParameter_swigregister", pairstringTWhiteBalanceParameter_swigregister, METH_O, NULL},
	 { "pairstringTWhiteBalanceParameter_swiginit", pairstringTWhiteBalanceParameter_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyI64", _wrap_new_PropertyI64, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI64** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI64** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to a 64-bit integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI64** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI64** object, this object shall be created from\n"
		""},
	 { "PropertyI64_getTranslationDict", _wrap_PropertyI64_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::int64_type >,std::allocator< std::pair< std::string,mvIMPACT::acquire::int64_type > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyI64_getTranslationDictString", _wrap_PropertyI64_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyI64_getTranslationDictValue", _wrap_PropertyI64_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyI64_getTranslationDictStrings", _wrap_PropertyI64_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyI64_getTranslationDictValues", _wrap_PropertyI64_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyI64_getMaxValue", _wrap_PropertyI64_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI64_getMinValue", _wrap_PropertyI64_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI64_getStepWidth", _wrap_PropertyI64_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI64_read", _wrap_PropertyI64_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyI64_write", _wrap_PropertyI64_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyI64", _wrap_delete_PropertyI64, METH_O, NULL},
	 { "PropertyI64_swigregister", PropertyI64_swigregister, METH_O, NULL},
	 { "PropertyI64_swiginit", PropertyI64_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringint64_type", _wrap_new_pairstringint64_type, METH_VARARGS, NULL},
	 { "pairstringint64_type_first_set", _wrap_pairstringint64_type_first_set, METH_VARARGS, NULL},
	 { "pairstringint64_type_first_get", _wrap_pairstringint64_type_first_get, METH_O, NULL},
	 { "pairstringint64_type_second_set", _wrap_pairstringint64_type_second_set, METH_VARARGS, NULL},
	 { "pairstringint64_type_second_get", _wrap_pairstringint64_type_second_get, METH_O, NULL},
	 { "delete_pairstringint64_type", _wrap_delete_pairstringint64_type, METH_O, NULL},
	 { "pairstringint64_type_swigregister", pairstringint64_type_swigregister, METH_O, NULL},
	 { "pairstringint64_type_swiginit", pairstringint64_type_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyI64BufferPartDataType", _wrap_new_PropertyI64BufferPartDataType, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI64** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI64** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to a 64-bit integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI64** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI64** object, this object shall be created from\n"
		""},
	 { "PropertyI64BufferPartDataType_getTranslationDict", _wrap_PropertyI64BufferPartDataType_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyI64BufferPartDataType_getTranslationDictString", _wrap_PropertyI64BufferPartDataType_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyI64BufferPartDataType_getTranslationDictValue", _wrap_PropertyI64BufferPartDataType_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyI64BufferPartDataType_getTranslationDictStrings", _wrap_PropertyI64BufferPartDataType_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyI64BufferPartDataType_getTranslationDictValues", _wrap_PropertyI64BufferPartDataType_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyI64BufferPartDataType_getMaxValue", _wrap_PropertyI64BufferPartDataType_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI64BufferPartDataType_getMinValue", _wrap_PropertyI64BufferPartDataType_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI64BufferPartDataType_getStepWidth", _wrap_PropertyI64BufferPartDataType_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI64BufferPartDataType_read", _wrap_PropertyI64BufferPartDataType_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyI64BufferPartDataType_write", _wrap_PropertyI64BufferPartDataType_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyI64BufferPartDataType", _wrap_delete_PropertyI64BufferPartDataType, METH_O, NULL},
	 { "PropertyI64BufferPartDataType_swigregister", PropertyI64BufferPartDataType_swigregister, METH_O, NULL},
	 { "PropertyI64BufferPartDataType_swiginit", PropertyI64BufferPartDataType_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTBufferPartDataType", _wrap_new_pairstringTBufferPartDataType, METH_VARARGS, NULL},
	 { "pairstringTBufferPartDataType_first_set", _wrap_pairstringTBufferPartDataType_first_set, METH_VARARGS, NULL},
	 { "pairstringTBufferPartDataType_first_get", _wrap_pairstringTBufferPartDataType_first_get, METH_O, NULL},
	 { "pairstringTBufferPartDataType_second_set", _wrap_pairstringTBufferPartDataType_second_set, METH_VARARGS, NULL},
	 { "pairstringTBufferPartDataType_second_get", _wrap_pairstringTBufferPartDataType_second_get, METH_O, NULL},
	 { "delete_pairstringTBufferPartDataType", _wrap_delete_pairstringTBufferPartDataType, METH_O, NULL},
	 { "pairstringTBufferPartDataType_swigregister", pairstringTBufferPartDataType_swigregister, METH_O, NULL},
	 { "pairstringTBufferPartDataType_swiginit", pairstringTBufferPartDataType_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyI64DeviceTriggerOverlap", _wrap_new_PropertyI64DeviceTriggerOverlap, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI64** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI64** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to a 64-bit integer property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyI64** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI64** object, this object shall be created from\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_getTranslationDict", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** and\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_getTranslationDictString", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_getTranslationDictValue", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_getTranslationDictStrings", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_getTranslationDictValues", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_getMaxValue", _wrap_PropertyI64DeviceTriggerOverlap_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_getMinValue", _wrap_PropertyI64DeviceTriggerOverlap_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_getStepWidth", _wrap_PropertyI64DeviceTriggerOverlap_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_read", _wrap_PropertyI64DeviceTriggerOverlap_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: int\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyI64DeviceTriggerOverlap_write", _wrap_PropertyI64DeviceTriggerOverlap_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: int\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyI64DeviceTriggerOverlap", _wrap_delete_PropertyI64DeviceTriggerOverlap, METH_O, NULL},
	 { "PropertyI64DeviceTriggerOverlap_swigregister", PropertyI64DeviceTriggerOverlap_swigregister, METH_O, NULL},
	 { "PropertyI64DeviceTriggerOverlap_swiginit", PropertyI64DeviceTriggerOverlap_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringTDeviceTriggerOverlap", _wrap_new_pairstringTDeviceTriggerOverlap, METH_VARARGS, NULL},
	 { "pairstringTDeviceTriggerOverlap_first_set", _wrap_pairstringTDeviceTriggerOverlap_first_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceTriggerOverlap_first_get", _wrap_pairstringTDeviceTriggerOverlap_first_get, METH_O, NULL},
	 { "pairstringTDeviceTriggerOverlap_second_set", _wrap_pairstringTDeviceTriggerOverlap_second_set, METH_VARARGS, NULL},
	 { "pairstringTDeviceTriggerOverlap_second_get", _wrap_pairstringTDeviceTriggerOverlap_second_get, METH_O, NULL},
	 { "delete_pairstringTDeviceTriggerOverlap", _wrap_delete_pairstringTDeviceTriggerOverlap, METH_O, NULL},
	 { "pairstringTDeviceTriggerOverlap_swigregister", pairstringTDeviceTriggerOverlap_swigregister, METH_O, NULL},
	 { "pairstringTDeviceTriggerOverlap_swiginit", pairstringTDeviceTriggerOverlap_swiginit, METH_VARARGS, NULL},
	 { "new_PropertyF", _wrap_new_PropertyF, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new unbound **mvIMPACT::acquire::EnumPropertyF** object.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyF** object.\n"
		":type hProp: int\n"
		":param hProp: [in] A valid handle to a float property\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::EnumPropertyF** from an existing one.\n"
		":type src: mvIMPACT::acquire::EnumPropertyF< double >\n"
		":param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyF** object, this object shall be created from\n"
		""},
	 { "PropertyF_getTranslationDict", _wrap_PropertyF_getTranslationDict, METH_VARARGS, "\n"
		" This function queries the property's translation table.\n"
		" If this property defines a translation table the strings and their corresponding\n"
		" translation values will be written into *sequence*. If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **EnumPropertyF::getTranslationDictString** and\n"
		" **EnumPropertyF::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyF< double >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >\n"
		":param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.\n"
		""},
	 { "PropertyF_getTranslationDictString", _wrap_PropertyF_getTranslationDictString, METH_VARARGS, "\n"
		" This function reads a single translation table string entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the string representation of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyF_getTranslationDictValue", _wrap_PropertyF_getTranslationDictValue, METH_VARARGS, "\n"
		" This function reads a single translation table value entry from a property.\n"
		" If this property defines a translation table and *index* specifies a valid entry\n"
		" the value of this entry will be returned.\n"
		" If the property does **NOT** define a translation table or *index* specifies\n"
		" an invalid entry an exception will be thrown.\n"
		" See also: **mvIMPACT::acquire::EnumPropertyF::getTranslationDictValues** to query all valid\n"
		" values efficiently in a single call.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the entry to read from the property.\n"
		""},
	 { "PropertyF_getTranslationDictStrings", _wrap_PropertyF_getTranslationDictStrings, METH_VARARGS, "\n"
		" This function queries a list of valid strings for this property.\n"
		" If this property defines a translation table all valid strings will be written into *sequence*.\n"
		" If the property does **NOT** define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyF::getTranslationDictString** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 2.5.0\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyF< double >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< std::string,std::allocator< std::string > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyF_getTranslationDictValues", _wrap_PropertyF_getTranslationDictValues, METH_VARARGS, "\n"
		" This function queries a list of valid values for this property.\n"
		" If this property defines a translation table all valid values will be written into *sequence*.\n"
		" If the property does **NOT**\n"
		" define a translation table *sequence* will be empty after this function call.\n"
		"\n"
		" Notes: \n"
		" This function is much more efficient than calling\n"
		" **mvIMPACT::acquire::EnumPropertyF::getTranslationDictValue** multiple times and\n"
		" therefore this function should be called whenever all entries are required.\n"
		" Since: 1.12.68\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyF< double >\n"
		" :return: A const reference to the calling property.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		""},
	 { "PropertyF_getMaxValue", _wrap_PropertyF_getMaxValue, METH_O, "\n"
		"Reads the maximum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a maximum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyF_getMinValue", _wrap_PropertyF_getMinValue, METH_O, "\n"
		"Reads the minimum value from a property.\n"
		"Notes: \n"
		"To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a minimum value calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyF_getStepWidth", _wrap_PropertyF_getStepWidth, METH_O, "\n"
		"Reads the step width from a property.\n"
		"Notes: \n"
		"To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**\n"
		"should be called first.\n"
		"\n"
		"\n"
		"If the property does not define a step width calling this function will raise\n"
		"an exception.\n"
		"\n"
		"Since: 1.12.63\n"
		""},
	 { "PropertyF_read", _wrap_PropertyF_read, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Reads a value from a property.\n"
		" This function queries a single value stored under index *index* in the property.\n"
		" :rtype: float\n"
		" :return: The value stored at *index* within the property.\n"
		"\n"
		":type index: int\n"
		":param index: [in] The index of the value to read from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":type end: int\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":type start: int\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 7:*\n"
		" Reads a set of values from a property.\n"
		" This function queries a set of values from a property and stores these values\n"
		" into *sequence*.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [out] A reference to a container to store the data read from the property into.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other\n"
		":param start: [in] The index from where to start reading values from the property.\n"
		":param end: [in] The index where to stop reading values from the property.\n"
		""},
	 { "PropertyF_write", _wrap_PropertyF_write, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Writes one value to the property.\n"
		" This function writes a single value under index *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyF< double >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type value: float\n"
		":param value: [in] The value to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index defining at which position to write the value.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyF< double >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyF< double >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyF< double >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":type index: int\n"
		":param index: [in] The index where to write the first value to the property.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Writes a set of values to the property.\n"
		" This function writes a set of values starting at *index* to the property.\n"
		"\n"
		" :rtype: mvIMPACT::acquire::EnumPropertyF< double >\n"
		" :return: A const 'self' reference.\n"
		"\n"
		":type sequence: std::vector< double,std::allocator< double > >\n"
		":param sequence: [in] An array containing the values to write to the property.\n"
		":type boAtomic: boolean\n"
		":param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other\n"
		":param index: [in] The index where to write the first value to the property.\n"
		""},
	 { "delete_PropertyF", _wrap_delete_PropertyF, METH_O, NULL},
	 { "PropertyF_swigregister", PropertyF_swigregister, METH_O, NULL},
	 { "PropertyF_swiginit", PropertyF_swiginit, METH_VARARGS, NULL},
	 { "new_pairstringdouble", _wrap_new_pairstringdouble, METH_VARARGS, NULL},
	 { "pairstringdouble_first_set", _wrap_pairstringdouble_first_set, METH_VARARGS, NULL},
	 { "pairstringdouble_first_get", _wrap_pairstringdouble_first_get, METH_O, NULL},
	 { "pairstringdouble_second_set", _wrap_pairstringdouble_second_set, METH_VARARGS, NULL},
	 { "pairstringdouble_second_get", _wrap_pairstringdouble_second_get, METH_O, NULL},
	 { "delete_pairstringdouble", _wrap_delete_pairstringdouble, METH_O, NULL},
	 { "pairstringdouble_swigregister", pairstringdouble_swigregister, METH_O, NULL},
	 { "pairstringdouble_swiginit", pairstringdouble_swiginit, METH_VARARGS, NULL},
	 { "new_DeviceControl", _wrap_new_DeviceControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::DeviceControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "DeviceControl_deviceType_get", _wrap_DeviceControl_deviceType_get, METH_O, "\n"
		"An enumerated integer property. Returns the device type.\n"
		"Returns the device type.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Transmitter** (Display string: 'Transmitter'): Data stream transmitter device.\n"
		"- **Receiver** (Display string: 'Receiver'): Data stream receiver device.\n"
		"- **Transceiver** (Display string: 'Transceiver'): Data stream receiver and transmitter device.\n"
		"- **Peripheral** (Display string: 'Peripheral'): Controllable device (with no data stream handling).\n"
		"- **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a device for a mixed protocol.\n"
		"- **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a device for a custom protocol.\n"
		"- **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a device for the GigE Vision protocol.\n"
		"- **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a device for the CameraLink protocol.\n"
		"- **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a device for the CoaXPress protocol.\n"
		"- **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a device for the CameraLink HS protocol.\n"
		"- **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a device for the USB3 Vision protocol.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceScanType_get", _wrap_DeviceControl_deviceScanType_get, METH_O, "\n"
		"An enumerated integer property. Scan type of the sensor of the device.\n"
		"Scan type of the sensor of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Areascan** (Display string: 'Areascan'): 2D sensor outputting an image created from a unique sensor acquisition.\n"
		"- **Linescan** (Display string: 'Linescan'): 1D sensor outputting an image acquired line by line.\n"
		"- **Areascan3D** (Display string: 'Areascan 3D'): 3D sensor outputting a range (or disparity) image created from a unique sensor acquisition.\n"
		"- **Linescan3D** (Display string: 'Linescan 3D'): 3D sensor outputting a range (or disparity) image acquired line by line.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceVendorName_get", _wrap_DeviceControl_deviceVendorName_get, METH_O, "\n"
		"A string property. Name of the manufacturer of the device.\n"
		"Name of the manufacturer of the device.\n"
		""},
	 { "DeviceControl_deviceModelName_get", _wrap_DeviceControl_deviceModelName_get, METH_O, "\n"
		"A string property. Model of the device.\n"
		"Model of the device.\n"
		""},
	 { "DeviceControl_deviceFamilyName_get", _wrap_DeviceControl_deviceFamilyName_get, METH_O, "\n"
		"A string property. Identifier of the product family of the device.\n"
		"Identifier of the product family of the device.\n"
		""},
	 { "DeviceControl_deviceManufacturerInfo_get", _wrap_DeviceControl_deviceManufacturerInfo_get, METH_O, "\n"
		"A string property. Manufacturer information about the device.\n"
		"Manufacturer information about the device.\n"
		""},
	 { "DeviceControl_deviceVersion_get", _wrap_DeviceControl_deviceVersion_get, METH_O, "\n"
		"A string property. Version of the device.\n"
		"Version of the device.\n"
		""},
	 { "DeviceControl_deviceFirmwareVersion_get", _wrap_DeviceControl_deviceFirmwareVersion_get, METH_O, "\n"
		"A string property. Version of the firmware in the device.\n"
		"Version of the firmware in the device.\n"
		""},
	 { "DeviceControl_mvDeviceFirmwareBuildDate_get", _wrap_DeviceControl_mvDeviceFirmwareBuildDate_get, METH_O, "\n"
		"A string property. The build time and date of the firmware\n"
		"The build time and date of the firmware\n"
		""},
	 { "DeviceControl_deviceSerialNumber_get", _wrap_DeviceControl_deviceSerialNumber_get, METH_O, "\n"
		"A string property. Device's serial number.\n"
		"Device's serial number. This string is a unique identifier of the device.\n"
		""},
	 { "DeviceControl_deviceID_get", _wrap_DeviceControl_deviceID_get, METH_O, "\n"
		"A string property. This feature is deprecated (See DeviceSerialNumber).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceSerialNumber). It was representing the Device unique identifier (serial number).\n"
		""},
	 { "DeviceControl_deviceUserID_get", _wrap_DeviceControl_deviceUserID_get, METH_O, "\n"
		"A string property. User-programmable device identifier.\n"
		"User-programmable device identifier.\n"
		""},
	 { "DeviceControl_deviceSFNCVersionMajor_get", _wrap_DeviceControl_deviceSFNCVersionMajor_get, METH_O, "\n"
		"An integer property. Major version of the Standard Features Naming Convention that was used to create the device's GenICam XML.\n"
		"Major version of the Standard Features Naming Convention that was used to create the device's GenICam XML.\n"
		""},
	 { "DeviceControl_deviceSFNCVersionMinor_get", _wrap_DeviceControl_deviceSFNCVersionMinor_get, METH_O, "\n"
		"An integer property. Minor version of the Standard Features Naming Convention that was used to create the device's GenICam XML.\n"
		"Minor version of the Standard Features Naming Convention that was used to create the device's GenICam XML.\n"
		""},
	 { "DeviceControl_deviceSFNCVersionSubMinor_get", _wrap_DeviceControl_deviceSFNCVersionSubMinor_get, METH_O, "\n"
		"An integer property. Sub minor version of Standard Features Naming Convention that was used to create the device's GenICam XML.\n"
		"Sub minor version of Standard Features Naming Convention that was used to create the device's GenICam XML.\n"
		""},
	 { "DeviceControl_deviceManifestEntrySelector_get", _wrap_DeviceControl_deviceManifestEntrySelector_get, METH_O, "\n"
		"An integer property. Selects the manifest entry to reference.\n"
		"Selects the manifest entry to reference.\n"
		""},
	 { "DeviceControl_deviceManifestXMLMajorVersion_get", _wrap_DeviceControl_deviceManifestXMLMajorVersion_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the GenICam XML file of the selected manifest entry.\n"
		"Indicates the major version number of the GenICam XML file of the selected manifest entry.\n"
		""},
	 { "DeviceControl_deviceManifestXMLMinorVersion_get", _wrap_DeviceControl_deviceManifestXMLMinorVersion_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the GenICam XML file of the selected manifest entry.\n"
		"Indicates the minor version number of the GenICam XML file of the selected manifest entry.\n"
		""},
	 { "DeviceControl_deviceManifestXMLSubMinorVersion_get", _wrap_DeviceControl_deviceManifestXMLSubMinorVersion_get, METH_O, "\n"
		"An integer property. Indicates the subminor version number of the GenICam XML file of the selected manifest entry.\n"
		"Indicates the subminor version number of the GenICam XML file of the selected manifest entry.\n"
		""},
	 { "DeviceControl_deviceManifestSchemaMajorVersion_get", _wrap_DeviceControl_deviceManifestSchemaMajorVersion_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the schema file of the selected manifest entry.\n"
		"Indicates the major version number of the schema file of the selected manifest entry.\n"
		""},
	 { "DeviceControl_deviceManifestSchemaMinorVersion_get", _wrap_DeviceControl_deviceManifestSchemaMinorVersion_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the schema file of the selected manifest entry.\n"
		"Indicates the minor version number of the schema file of the selected manifest entry.\n"
		""},
	 { "DeviceControl_deviceManifestPrimaryURL_get", _wrap_DeviceControl_deviceManifestPrimaryURL_get, METH_O, "\n"
		"A string property. Indicates the first URL to the GenICam XML device description file of the selected manifest entry.\n"
		"Indicates the first URL to the GenICam XML device description file of the selected manifest entry.\n"
		""},
	 { "DeviceControl_deviceManifestSecondaryURL_get", _wrap_DeviceControl_deviceManifestSecondaryURL_get, METH_O, "\n"
		"A string property. Indicates the second URL to the GenICam XML device description file of the selected manifest entry.\n"
		"Indicates the second URL to the GenICam XML device description file of the selected manifest entry.\n"
		""},
	 { "DeviceControl_deviceTLType_get", _wrap_DeviceControl_deviceTLType_get, METH_O, "\n"
		"An enumerated integer property. Transport Layer type of the device.\n"
		"Transport Layer type of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **GigEVision** (Display string: 'GigE Vision'): GigE Vision.\n"
		"- **CameraLink** (Display string: 'Camera Link'): Camera Link.\n"
		"- **CameraLinkHS** (Display string: 'Camera Link HS'): Camera Link High Speed.\n"
		"- **CoaXPress** (Display string: 'CoaXPress'): CoaXPress.\n"
		"- **USB3Vision** (Display string: 'USB3 Vision'): USB3 Vision.\n"
		"- **Custom** (Display string: 'Custom'): Custom Transport Layer.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceTLVersionMajor_get", _wrap_DeviceControl_deviceTLVersionMajor_get, METH_O, "\n"
		"An integer property. Major version of the Transport Layer of the device.\n"
		"Major version of the Transport Layer of the device.\n"
		""},
	 { "DeviceControl_deviceTLVersionMinor_get", _wrap_DeviceControl_deviceTLVersionMinor_get, METH_O, "\n"
		"An integer property. Minor version of the Transport Layer of the device.\n"
		"Minor version of the Transport Layer of the device.\n"
		""},
	 { "DeviceControl_deviceTLVersionSubMinor_get", _wrap_DeviceControl_deviceTLVersionSubMinor_get, METH_O, "\n"
		"An integer property. Sub minor version of the Transport Layer of the device.\n"
		"Sub minor version of the Transport Layer of the device.\n"
		""},
	 { "DeviceControl_deviceGenCPVersionMajor_get", _wrap_DeviceControl_deviceGenCPVersionMajor_get, METH_O, "\n"
		"An integer property. Major version of the GenCP protocol supported by the device.\n"
		"Major version of the GenCP protocol supported by the device.\n"
		""},
	 { "DeviceControl_deviceGenCPVersionMinor_get", _wrap_DeviceControl_deviceGenCPVersionMinor_get, METH_O, "\n"
		"An integer property. Minor version of the GenCP protocol supported by the device.\n"
		"Minor version of the GenCP protocol supported by the device.\n"
		""},
	 { "DeviceControl_deviceMaxThroughput_get", _wrap_DeviceControl_deviceMaxThroughput_get, METH_O, "\n"
		"An integer property. Maximum bandwidth of the data that can be streamed out of the device.\n"
		"Maximum bandwidth of the data that can be streamed out of the device. This can be used to estimate if the physical connection(s) can sustain transfer of free-running images from the camera at its maximum speed.\n"
		""},
	 { "DeviceControl_deviceConnectionSelector_get", _wrap_DeviceControl_deviceConnectionSelector_get, METH_O, "\n"
		"An integer property. Selects which Connection of the device to control.\n"
		"Selects which Connection of the device to control.\n"
		""},
	 { "DeviceControl_deviceConnectionSpeed_get", _wrap_DeviceControl_deviceConnectionSpeed_get, METH_O, "\n"
		"An integer property. Indicates the speed of transmission of the specified Connection.\n"
		"Indicates the speed of transmission of the specified Connection\n"
		""},
	 { "DeviceControl_deviceConnectionStatus_get", _wrap_DeviceControl_deviceConnectionStatus_get, METH_O, "\n"
		"An enumerated integer property. Indicates the status of the specified Connection.\n"
		"Indicates the status of the specified Connection.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Active** (Display string: 'Active'): Connection is in use.\n"
		"- **Inactive** (Display string: 'Inactive'): Connection is not in use.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceLinkSelector_get", _wrap_DeviceControl_deviceLinkSelector_get, METH_O, "\n"
		"An integer property. Selects which Link of the device to control.\n"
		"Selects which Link of the device to control.\n"
		""},
	 { "DeviceControl_deviceLinkSpeed_get", _wrap_DeviceControl_deviceLinkSpeed_get, METH_O, "\n"
		"An integer property. Indicates the speed of transmission negotiated on the specified Link.\n"
		"Indicates the speed of transmission negotiated on the specified Link.\n"
		""},
	 { "DeviceControl_deviceLinkThroughputLimitMode_get", _wrap_DeviceControl_deviceLinkThroughputLimitMode_get, METH_O, "\n"
		"An enumerated integer property. Controls if the DeviceLinkThroughputLimit is active.\n"
		"Controls if the DeviceLinkThroughputLimit is active. When disabled, lower level TL specific features are expected to control the throughput. When enabled, DeviceLinkThroughputLimit controls the overall throughput.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **On** (Display string: 'On'): Enables the DeviceLinkThroughputLimit feature.\n"
		"- **Off** (Display string: 'Off'): Disables the DeviceLinkThroughputLimit feature.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceLinkThroughputLimit_get", _wrap_DeviceControl_deviceLinkThroughputLimit_get, METH_O, "\n"
		"An integer property. Limits the maximum bandwidth of the data that will be streamed out by the device on the selected Link.\n"
		"Limits the maximum bandwidth of the data that will be streamed out by the device on the selected Link. If necessary, delays will be uniformly inserted between transport layer packets in order to control the peak bandwidth.\n"
		""},
	 { "DeviceControl_deviceLinkConnectionCount_get", _wrap_DeviceControl_deviceLinkConnectionCount_get, METH_O, "\n"
		"An integer property. Returns the number of physical connection of the device used by a particular Link.\n"
		"Returns the number of physical connection of the device used by a particular Link.\n"
		""},
	 { "DeviceControl_deviceLinkHeartbeatMode_get", _wrap_DeviceControl_deviceLinkHeartbeatMode_get, METH_O, "\n"
		"An enumerated integer property. Activate or deactivate the Link's heartbeat.\n"
		"Activate or deactivate the Link's heartbeat.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **On** (Display string: 'On'): Enables the Link heartbeat.\n"
		"- **Off** (Display string: 'Off'): Disables the Link heartbeat.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceLinkHeartbeatTimeout_get", _wrap_DeviceControl_deviceLinkHeartbeatTimeout_get, METH_O, "\n"
		"A floating point property. Controls the current heartbeat timeout of the specific Link.\n"
		"Controls the current heartbeat timeout of the specific Link.\n"
		""},
	 { "DeviceControl_deviceLinkCommandTimeout_get", _wrap_DeviceControl_deviceLinkCommandTimeout_get, METH_O, "\n"
		"A floating point property. Indicates the command timeout of the specified Link.\n"
		"Indicates the command timeout of the specified Link. This corresponds to the maximum response time of the device for a command sent on that link.\n"
		""},
	 { "DeviceControl_deviceStreamChannelCount_get", _wrap_DeviceControl_deviceStreamChannelCount_get, METH_O, "\n"
		"An integer property. Indicates the number of streaming channels supported by the device.\n"
		"Indicates the number of streaming channels supported by the device.\n"
		""},
	 { "DeviceControl_deviceStreamChannelSelector_get", _wrap_DeviceControl_deviceStreamChannelSelector_get, METH_O, "\n"
		"An integer property. Selects the stream channel to control.\n"
		"Selects the stream channel to control.\n"
		""},
	 { "DeviceControl_deviceStreamChannelType_get", _wrap_DeviceControl_deviceStreamChannelType_get, METH_O, "\n"
		"An enumerated integer property. Reports the type of the stream channel.\n"
		"Reports the type of the stream channel.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Transmitter** (Display string: 'Transmitter'): Data stream transmitter channel.\n"
		"- **Receiver** (Display string: 'Receiver'): Data stream receiver channel.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceStreamChannelLink_get", _wrap_DeviceControl_deviceStreamChannelLink_get, METH_O, "\n"
		"An integer property. Index of device's Link to use for streaming the specified stream channel.\n"
		"Index of device's Link to use for streaming the specified stream channel.\n"
		""},
	 { "DeviceControl_deviceStreamChannelEndianness_get", _wrap_DeviceControl_deviceStreamChannelEndianness_get, METH_O, "\n"
		"An enumerated integer property. Endianness of multi-byte pixel data for this stream.\n"
		"Endianness of multi-byte pixel data for this stream.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Big** (Display string: 'Big'): Stream channel data is big Endian.\n"
		"- **Little** (Display string: 'Little'): Stream channel data is little Endian.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceStreamChannelPacketSize_get", _wrap_DeviceControl_deviceStreamChannelPacketSize_get, METH_O, "\n"
		"An integer property. Specifies the stream packet size, in bytes, to send on the selected channel for a Transmitter or specifies the maximum packet size supported by a receiver.\n"
		"Specifies the stream packet size, in bytes, to send on the selected channel for a Transmitter or specifies the maximum packet size supported by a receiver.\n"
		""},
	 { "DeviceControl_deviceEventChannelCount_get", _wrap_DeviceControl_deviceEventChannelCount_get, METH_O, "\n"
		"An integer property. Indicates the number of event channels supported by the device.\n"
		"Indicates the number of event channels supported by the device.\n"
		""},
	 { "DeviceControl_deviceMessageChannelCount_get", _wrap_DeviceControl_deviceMessageChannelCount_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See DeviceEventChannelCount).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceEventChannelCount). It indicates the number of message/event channels supported by the device.\n"
		""},
	 { "DeviceControl_deviceCharacterSet_get", _wrap_DeviceControl_deviceCharacterSet_get, METH_O, "\n"
		"An enumerated integer property. Character set used by the strings of the device.\n"
		"Character set used by the strings of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **UTF8** (Display string: 'UTF 8'): Device use UTF8 character set.\n"
		"- **ASCII** (Display string: 'ASCII'): Device use ASCII character set.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceReset_get", _wrap_DeviceControl_deviceReset_get, METH_O, "\n"
		"A method object. Resets the device to its power up state.\n"
		"Resets the device to its power up state. After reset, the device must be rediscovered.\n"
		""},
	 { "DeviceControl_deviceIndicatorMode_get", _wrap_DeviceControl_deviceIndicatorMode_get, METH_O, "\n"
		"An enumerated integer property. Controls the behavior of the indicators (such as LEDs) showing the status of the Device.\n"
		"Controls the behavior of the indicators (such as LEDs) showing the status of the Device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Inactive** (Display string: 'Inactive'): Device's indicators are inactive (Off).\n"
		"- **Active** (Display string: 'Active'): Device's indicators are active showing their respective status.\n"
		"- **ErrorStatus** (Display string: 'Error Status'): Device's indicators are inactive unless an error occurs.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceFeaturePersistenceStart_get", _wrap_DeviceControl_deviceFeaturePersistenceStart_get, METH_O, "\n"
		"A method object. Indicate to the device and GenICam XML to get ready for persisting of all streamable features.\n"
		"Indicate to the device and GenICam XML to get ready for persisting of all streamable features.\n"
		""},
	 { "DeviceControl_deviceFeaturePersistenceEnd_get", _wrap_DeviceControl_deviceFeaturePersistenceEnd_get, METH_O, "\n"
		"A method object. Indicate to the device the end of feature persistence.\n"
		"Indicate to the device the end of feature persistence.\n"
		""},
	 { "DeviceControl_deviceRegistersStreamingStart_get", _wrap_DeviceControl_deviceRegistersStreamingStart_get, METH_O, "\n"
		"A method object. Prepare the device for registers streaming without checking for consistency.\n"
		"Prepare the device for registers streaming without checking for consistency.\n"
		""},
	 { "DeviceControl_deviceRegistersStreamingEnd_get", _wrap_DeviceControl_deviceRegistersStreamingEnd_get, METH_O, "\n"
		"A method object. Announce the end of registers streaming.\n"
		"Announce the end of registers streaming. This will do a register set validation for consistency and activate it. This will also update the DeviceRegistersValid flag.\n"
		""},
	 { "DeviceControl_deviceRegistersCheck_get", _wrap_DeviceControl_deviceRegistersCheck_get, METH_O, "\n"
		"A method object. Perform the validation of the current register set for consistency.\n"
		"Perform the validation of the current register set for consistency. This will update the DeviceRegistersValid flag.\n"
		""},
	 { "DeviceControl_deviceRegistersValid_get", _wrap_DeviceControl_deviceRegistersValid_get, METH_O, "\n"
		"A boolean property. Returns if the current register set is valid and consistent.\n"
		"Returns if the current register set is valid and consistent.\n"
		""},
	 { "DeviceControl_mvDeviceRegistersStatus_get", _wrap_DeviceControl_mvDeviceRegistersStatus_get, METH_O, "\n"
		"An enumerated integer property. Will give a hint where to find the invalid register settings if any.\n"
		"Will give a hint where to find the invalid register settings if any.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Valid** (Display string: 'Valid'): The current register settings are in a consistent state.\n"
		"- **Invalid** (Display string: 'Invalid'): The current register settings are in an invalid and/or inconsistent state.\n"
		"- **BinningHorizontalValueInvalid** (Display string: 'Binning Horizontal Value Invalid'): The current BinningHorizontal value is not supported.\n"
		"- **BinningVerticalValueInvalid** (Display string: 'Binning Vertical Value Invalid'): The current BinningVertical value is not supported.\n"
		"- **DecimationHorizontalValueInvalid** (Display string: 'Decimation Horizontal Value Invalid'): The current DecimationHorizontal value is not supported.\n"
		"- **DecimationVerticalValueInvalid** (Display string: 'Decimation Vertical Value Invalid'): The current DecimationVertical value is not supported.\n"
		"- **BinningDecimationCombinationInvalid** (Display string: 'Binning Decimation Combination Invalid'): The current combination of binning and decimation is not valid.\n"
		"- **BinningDecimationImageTooWide** (Display string: 'Binning Decimation Image Too Wide'): The current Width is too wide for the BinningVertical and/or DecimationVertical settings. Please reduce the Width or add BinningHorizontal orDecimationHorizontal.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceRegistersEndianness_get", _wrap_DeviceControl_deviceRegistersEndianness_get, METH_O, "\n"
		"An enumerated integer property. Endianness of the registers of the device.\n"
		"Endianness of the registers of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Big** (Display string: 'Big'): Device's registers are big Endian.\n"
		"- **Little** (Display string: 'Little'): Device's registers are little Endian.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceTemperatureSelector_get", _wrap_DeviceControl_deviceTemperatureSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the location within the device, where the temperature will be measured.\n"
		"Selects the location within the device, where the temperature will be measured.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Sensor** (Display string: 'Sensor'): Temperature of the image sensor of the camera.\n"
		"- **Mainboard** (Display string: 'Mainboard'): Temperature of the device's mainboard.\n"
		"- **XLamp** (Display string: 'X Lamp')\n"
		"- **SensorCMVx000** (Display string: 'Sensor CM Vx 000')\n"
		"- **SensorInternal** (Display string: 'Sensor Internal')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceTemperature_get", _wrap_DeviceControl_deviceTemperature_get, METH_O, "\n"
		"A floating point property. Device temperature in degrees Celsius (C).\n"
		"Device temperature in degrees Celsius (C). It is measured at the location selected by DeviceTemperatureSelector.\n"
		""},
	 { "DeviceControl_deviceClockSelector_get", _wrap_DeviceControl_deviceClockSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the clock frequency to access from the device.\n"
		"Selects the clock frequency to access from the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Sensor** (Display string: 'Sensor'): Clock frequency of the image sensor of the camera.\n"
		"- **SensorDigitization** (Display string: 'Sensor Digitization'): Clock frequency of the camera A/D conversion stage.\n"
		"- **CameraLink** (Display string: 'Camera Link'): Frequency of the Camera Link clock.\n"
		"- **DeviceSpecific** (Display string: 'Device Specific')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceClockFrequency_get", _wrap_DeviceControl_deviceClockFrequency_get, METH_O, "\n"
		"A floating point property. Returns the frequency of the selected Clock.\n"
		"Returns the frequency of the selected Clock.\n"
		""},
	 { "DeviceControl_deviceSerialPortSelector_get", _wrap_DeviceControl_deviceSerialPortSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which serial port of the device to control.\n"
		"Selects which serial port of the device to control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **CameraLink** (Display string: 'Camera Link'): Serial port associated to the Camera link connection.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_deviceSerialPortBaudRate_get", _wrap_DeviceControl_deviceSerialPortBaudRate_get, METH_O, "\n"
		"An enumerated integer property. This feature controls the baud rate used by the selected serial port.\n"
		"This feature controls the baud rate used by the selected serial port.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Baud9600** (Display string: 'Baud 9600'): Serial port speed of 9600 baud.\n"
		"- **Baud19200** (Display string: 'Baud 19200'): Serial port speed of 19200 baud.\n"
		"- **Baud38400** (Display string: 'Baud 38400'): Serial port speed of 38400 baud.\n"
		"- **Baud57600** (Display string: 'Baud 57600'): Serial port speed of 57600 baud.\n"
		"- **Baud115200** (Display string: 'Baud 115200'): Serial port speed of 115200 baud.\n"
		"- **Baud230400** (Display string: 'Baud 230400'): Serial port speed of 230400 baud.\n"
		"- **Baud460800** (Display string: 'Baud 460800'): Serial port speed of 460800 baud.\n"
		"- **Baud921600** (Display string: 'Baud 921600'): Serial port speed of 921600 baud.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_timestamp_get", _wrap_DeviceControl_timestamp_get, METH_O, "\n"
		"An integer property. Reports the current value of the device timestamp counter.\n"
		"Reports the current value of the device timestamp counter.\n"
		""},
	 { "DeviceControl_timestampReset_get", _wrap_DeviceControl_timestampReset_get, METH_O, "\n"
		"A method object. Resets the current value of the device timestamp counter.\n"
		"Resets the current value of the device timestamp counter.\n"
		""},
	 { "DeviceControl_timestampLatch_get", _wrap_DeviceControl_timestampLatch_get, METH_O, "\n"
		"A method object. Latches the current timestamp counter into TimestampLatchValue.\n"
		"Latches the current timestamp counter into TimestampLatchValue.\n"
		""},
	 { "DeviceControl_timestampLatchValue_get", _wrap_DeviceControl_timestampLatchValue_get, METH_O, "\n"
		"An integer property. Returns the latched value of the timestamp counter.\n"
		"Returns the latched value of the timestamp counter.\n"
		""},
	 { "DeviceControl_rcSystemReady_get", _wrap_DeviceControl_rcSystemReady_get, METH_O, "\n"
		"A boolean property. Returns if the system is ready (fully booted).\n"
		"Returns if the system is ready (fully booted).\n"
		""},
	 { "DeviceControl_mvDeviceTemperatureRaw_get", _wrap_DeviceControl_mvDeviceTemperatureRaw_get, METH_O, "\n"
		"An integer property. Device temperature in degrees Celsius (C).\n"
		"Device temperature in degrees Celsius (C). It is measured at the location selected by DeviceTemperatureSelector.\n"
		""},
	 { "DeviceControl_mvDeviceTemperatureUpperLimit_get", _wrap_DeviceControl_mvDeviceTemperatureUpperLimit_get, METH_O, "\n"
		"A floating point property. Upper limit in degrees Celsius(C) for the TemperatureOutOfRange signal.\n"
		"Upper limit in degrees Celsius(C) for the TemperatureOutOfRange signal.\n"
		""},
	 { "DeviceControl_mvDeviceTemperatureLowerLimit_get", _wrap_DeviceControl_mvDeviceTemperatureLowerLimit_get, METH_O, "\n"
		"A floating point property. Lower limit in degrees Celsius(C) for the TemperatureOutOfRange signal.\n"
		"Lower limit in degrees Celsius(C) for the TemperatureOutOfRange signal.\n"
		""},
	 { "DeviceControl_mvDeviceTemperatureLimitHysteresis_get", _wrap_DeviceControl_mvDeviceTemperatureLimitHysteresis_get, METH_O, "\n"
		"An enumerated integer property. Hysteresis in degrees Celsius(C) for temperature limits.\n"
		"Hysteresis in degrees Celsius(C) for temperature limits.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **deg_0p0** (Display string: 'deg 0p 0')\n"
		"- **deg_1p5** (Display string: 'deg 1p 5')\n"
		"- **deg_3p0** (Display string: 'deg 3p 0')\n"
		"- **deg_6p0** (Display string: 'deg 6p 0')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvDeviceClockFrequency_get", _wrap_DeviceControl_mvDeviceClockFrequency_get, METH_O, "\n"
		"An enumerated integer property. Clock frequency of the image sensor of the camera.\n"
		"Clock frequency of the image sensor of the camera.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **kHz_08000** (Display string: '8000 kHz')\n"
		"- **kHz_10000** (Display string: '10000 kHz')\n"
		"- **kHz_11000** (Display string: '11000 kHz')\n"
		"- **kHz_12000** (Display string: '12000 kHz')\n"
		"- **kHz_20000** (Display string: '20000 kHz')\n"
		"- **kHz_22000** (Display string: '22000 kHz')\n"
		"- **kHz_23000** (Display string: '23000 kHz')\n"
		"- **kHz_24000** (Display string: '24000 kHz')\n"
		"- **kHz_24540** (Display string: '24540 kHz')\n"
		"- **kHz_25000** (Display string: '25000 kHz')\n"
		"- **kHz_26000** (Display string: '26000 kHz')\n"
		"- **kHz_27000** (Display string: '27000 kHz')\n"
		"- **kHz_28000** (Display string: '28000 kHz')\n"
		"- **kHz_29000** (Display string: '29000 kHz')\n"
		"- **kHz_29500** (Display string: '29500 kHz')\n"
		"- **kHz_30000** (Display string: '30000 kHz')\n"
		"- **kHz_32000** (Display string: '32000 kHz')\n"
		"- **kHz_36000** (Display string: '36000 kHz')\n"
		"- **kHz_37120** (Display string: '37120 kHz')\n"
		"- **kHz_40000** (Display string: '40000 kHz')\n"
		"- **kHz_45000** (Display string: '45000 kHz')\n"
		"- **kHz_48000** (Display string: '48000 kHz')\n"
		"- **kHz_50000** (Display string: '50000 kHz')\n"
		"- **kHz_56000** (Display string: '56000 kHz')\n"
		"- **kHz_60000** (Display string: '60000 kHz')\n"
		"- **kHz_65000** (Display string: '65000 kHz')\n"
		"- **kHz_66000** (Display string: '66000 kHz')\n"
		"- **kHz_74250** (Display string: '74250 kHz')\n"
		"- **kHz_80000** (Display string: '80000 kHz')\n"
		"- **kHz_85000** (Display string: '85000 kHz')\n"
		"- **kHz_96000** (Display string: '96000 kHz')\n"
		"- **kHz_98000** (Display string: '98000 kHz')\n"
		"- **kHz_120000** (Display string: '120000 kHz')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvDeviceSensorColorMode_get", _wrap_DeviceControl_mvDeviceSensorColorMode_get, METH_O, "\n"
		"An enumerated integer property. Shows color mode of the sensor.\n"
		"Shows color mode of the sensor.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Unknown** (Display string: 'Unknown')\n"
		"- **Grey** (Display string: 'Grey')\n"
		"- **BayerMosaic** (Display string: 'Bayer Mosaic')\n"
		"- **NearInfraRed** (Display string: 'Near Infra Red')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvDeviceFPGAVersion_get", _wrap_DeviceControl_mvDeviceFPGAVersion_get, METH_O, "\n"
		"A string property. Shows version number of the FPGA.\n"
		"Shows version number of the FPGA.\n"
		""},
	 { "DeviceControl_mvDeviceFirmwareSource_get", _wrap_DeviceControl_mvDeviceFirmwareSource_get, METH_O, "\n"
		"An enumerated integer property. Shows the location from where the firmware was loaded.\n"
		"Shows the location from where the firmware was loaded.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **BootSection** (Display string: 'Boot Section')\n"
		"- **ProgramSection** (Display string: 'Program Section')\n"
		"- **Upload** (Display string: 'Upload')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvDeviceProcessingUnitSelector_get", _wrap_DeviceControl_mvDeviceProcessingUnitSelector_get, METH_O, "\n"
		"An integer property. Selects the device processing unit.\n"
		"Selects the device processing unit.\n"
		""},
	 { "DeviceControl_mvDeviceProcessingUnit_get", _wrap_DeviceControl_mvDeviceProcessingUnit_get, METH_O, "\n"
		"An enumerated integer property. The processing unit to activate for the selected processing unit.\n"
		"The processing unit to activate for the selected processing unit.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvFFC** (Display string: 'mv FFC'): Selects the Flat-field correction engine for this processing unit.\n"
		"- **mvFrameAverage** (Display string: 'mv Frame Average'): Selects the frame average engine for this processing unit.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvDeviceStatusLEDEnable_get", _wrap_DeviceControl_mvDeviceStatusLEDEnable_get, METH_O, "\n"
		"A boolean property. This feature is deprecated (See DeviceIndicatorMode). If enabled, the color of the LED changes depending on the state of the camera. Otherwise the LED is Off.\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceIndicatorMode). If enabled, the color of the LED changes depending on the state of the camera. Otherwise the LED is Off.\n"
		""},
	 { "DeviceControl_mvDevicePowerMode_get", _wrap_DeviceControl_mvDevicePowerMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the device power mode.\n"
		"Selects the device power mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvActive** (Display string: 'mv Active'): Puts the device to power-active mode. Going back to 'mvActive' will take about 10 seconds.\n"
		"- **mvStandby** (Display string: 'mv Standby'): Puts the device in power-saving mode. In this mode the device will only consume up to 20 percent of its normal power consumption. Going back to 'mvActive' will take about 10 seconds.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvDeviceStandbyTimeoutEnable_get", _wrap_DeviceControl_mvDeviceStandbyTimeoutEnable_get, METH_O, "\n"
		"A boolean property. If enabled, the device switch to standby after a configurable time if no register is read.\n"
		"If enabled, the device switch to standby after a configurable time if no register is read.\n"
		""},
	 { "DeviceControl_mvDeviceStandbyTimeout_get", _wrap_DeviceControl_mvDeviceStandbyTimeout_get, METH_O, "\n"
		"An integer property. Defines the time in seconds after which the device automatically switches to standby if no register is read.\n"
		"Defines the time in seconds after which the device automatically switches to standby if no register is read.\n"
		""},
	 { "DeviceControl_mvDeviceFirmwareHashCode_get", _wrap_DeviceControl_mvDeviceFirmwareHashCode_get, METH_O, "\n"
		"A string property. Shows the hash code of the firmware.\n"
		"Shows the hash code of the firmware.\n"
		""},
	 { "DeviceControl_mvCalculateHashCode_get", _wrap_DeviceControl_mvCalculateHashCode_get, METH_O, "\n"
		"A method object. Do a new calculation of the hash code. This might serve as a means to check whether the firmware has been changed in flash.\n"
		"Do a new calculation of the hash code. This might serve as a means to check whether the firmware has been changed in flash. Caution: This needs approximately 15-20 seconds.\n"
		""},
	 { "DeviceControl_mvDeviceFirmwareHashAlgorithm_get", _wrap_DeviceControl_mvDeviceFirmwareHashAlgorithm_get, METH_O, "\n"
		"An enumerated integer property. The algorithm used for the hash calculation.\n"
		"The algorithm used for the hash calculation.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvCRC32b** (Display string: 'mv CRC 32b'): CRC32b will be used.\n"
		"- **mvSHA1** (Display string: 'mv SHA 1'): SHA1 will be used.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvDeviceLaserCurrent_get", _wrap_DeviceControl_mvDeviceLaserCurrent_get, METH_O, "\n"
		"An integer property. Laser current consumption value (mA).\n"
		"Laser current consumption value (mA).\n"
		""},
	 { "DeviceControl_mvTimestampPPSSync_get", _wrap_DeviceControl_mvTimestampPPSSync_get, METH_O, "\n"
		"An enumerated integer property. Will synchronize the internal clock to an external GPS(PPS) signal.\n"
		"Will synchronize the internal clock to an external GPS(PPS) signal.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **Line4** (Display string: 'Line 4')\n"
		"- **Line5** (Display string: 'Line 5')\n"
		"- **Line6** (Display string: 'Line 6')\n"
		"- **Line7** (Display string: 'Line 7')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvTimestampPPSTriggerEdge_get", _wrap_DeviceControl_mvTimestampPPSTriggerEdge_get, METH_O, "\n"
		"An enumerated integer property. Selects the trigger edge on which the controller will be pulsed.\n"
		"Selects the trigger edge on which the controller will be pulsed.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvRisingEdge** (Display string: 'mv Rising Edge'): Controller is pulsed on rising edges.\n"
		"- **mvFallingEdge** (Display string: 'mv Falling Edge'): Controller is pulsed on falling edges.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvTimestampPPSPulsesMissed_get", _wrap_DeviceControl_mvTimestampPPSPulsesMissed_get, METH_O, "\n"
		"An integer property. Shows the number of missed pulses since the last status latch.\n"
		"Shows the number of missed pulses since the last status latch.\n"
		""},
	 { "DeviceControl_mvTimestampPPSStatus_get", _wrap_DeviceControl_mvTimestampPPSStatus_get, METH_O, "\n"
		"An enumerated integer property. Shows the current status of the pulse per second controller.\n"
		"Shows the current status of the pulse per second controller.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Disabled** (Display string: 'Disabled'): Controller is disabled.\n"
		"- **NoPulses** (Display string: 'No Pulses'): Controller is enabled but pps pulses are missing.\n"
		"- **Unstable** (Display string: 'Unstable'): Controller has not reached the steady state so far.\n"
		"- **Stable** (Display string: 'Stable'): Controller has reached the range of steady state.\n"
		"- **Error** (Display string: 'Error'): Controller is in faulty state and must be reenabled manually.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvTimestampResetValue_get", _wrap_DeviceControl_mvTimestampResetValue_get, METH_O, "\n"
		"An integer property. Defines the initial value after the cameras timestamp timer has been reset.\n"
		"Defines the initial value after the cameras timestamp timer has been reset.\n"
		""},
	 { "DeviceControl_mvDeviceTimeSync_get", _wrap_DeviceControl_mvDeviceTimeSync_get, METH_O, "\n"
		"An enumerated integer property. you can specify the way the camera timestamps are synchronized to the PC / your application\n"
		"you can specify the way the camera timestamps are synchronized to the PC / your application\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvSystemTime** (Display string: 'mv System Time')\n"
		"- **mvNoSynchronization** (Display string: 'mv No Synchronization')\n"
		"- **mvPushSynchronization** (Display string: 'mv Push Synchronization')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvDeviceTimeSyncPushValue_get", _wrap_DeviceControl_mvDeviceTimeSyncPushValue_get, METH_O, "\n"
		"An integer property. when you write to this register in 'mvPushSynchronization'-mode you can actively synchronize the timestamps with accurate time values\n"
		"when you write to this register in 'mvPushSynchronization'-mode you can actively synchironize the timestamps with accurate time values\n"
		""},
	 { "DeviceControl_mvTemperatureState_get", _wrap_DeviceControl_mvTemperatureState_get, METH_O, "\n"
		"An enumerated integer property. Indicates the current temperature state of the camera\n"
		"Indicates the current temperature state of the camera\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Normal** (Display string: 'Normal')\n"
		"- **Critical** (Display string: 'Critical')\n"
		"- **OverTemperature** (Display string: 'Over Temperature')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceControl_mvTemperatureStateCriticalThreshold_get", _wrap_DeviceControl_mvTemperatureStateCriticalThreshold_get, METH_O, "\n"
		"An integer property. If the temperature of the camera exceeds this value mvTemperatureState switches from normal to critical\n"
		"If the temperature of the camera exceeds this value mvTemperatureState switches from normal to critical\n"
		""},
	 { "delete_DeviceControl", _wrap_delete_DeviceControl, METH_O, NULL},
	 { "DeviceControl_swigregister", DeviceControl_swigregister, METH_O, NULL},
	 { "DeviceControl_swiginit", DeviceControl_swiginit, METH_VARARGS, NULL},
	 { "new_ImageFormatControl", _wrap_new_ImageFormatControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::ImageFormatControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "ImageFormatControl_sensorWidth_get", _wrap_ImageFormatControl_sensorWidth_get, METH_O, "\n"
		"An integer property. Effective width of the sensor in pixels.\n"
		"Effective width of the sensor in pixels.\n"
		""},
	 { "ImageFormatControl_sensorHeight_get", _wrap_ImageFormatControl_sensorHeight_get, METH_O, "\n"
		"An integer property. Effective height of the sensor in pixels.\n"
		"Effective height of the sensor in pixels.\n"
		""},
	 { "ImageFormatControl_sensorPixelWidth_get", _wrap_ImageFormatControl_sensorPixelWidth_get, METH_O, "\n"
		"A floating point property. Physical size (pitch) in the x direction of a photo sensitive pixel unit.\n"
		"Physical size (pitch) in the x direction of a photo sensitive pixel unit.\n"
		""},
	 { "ImageFormatControl_sensorPixelHeight_get", _wrap_ImageFormatControl_sensorPixelHeight_get, METH_O, "\n"
		"A floating point property. Physical size (pitch) in the y direction of a photo sensitive pixel unit.\n"
		"Physical size (pitch) in the y direction of a photo sensitive pixel unit.\n"
		""},
	 { "ImageFormatControl_sensorName_get", _wrap_ImageFormatControl_sensorName_get, METH_O, "\n"
		"A string property. Product name of the imaging Sensor.\n"
		"Product name of the imaging Sensor.\n"
		""},
	 { "ImageFormatControl_sensorShutterMode_get", _wrap_ImageFormatControl_sensorShutterMode_get, METH_O, "\n"
		"An enumerated integer property. Specifies the shutter mode of the device.\n"
		"Specifies the shutter mode of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Global** (Display string: 'Global'): The shutter opens and closes at the same time for all pixels. All the pixels are exposed for the same length of time at the same time.\n"
		"- **Rolling** (Display string: 'Rolling'): The shutter opens and closes sequentially for groups (typically lines) of pixels. All the pixels are exposed for the same length of time but not at the same time.\n"
		"- **GlobalReset** (Display string: 'Global Reset'): The shutter opens at the same time for all pixels but ends in a sequential manner. The pixels are exposed for different lengths of time.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_sensorTaps_get", _wrap_ImageFormatControl_sensorTaps_get, METH_O, "\n"
		"An enumerated integer property. Number of taps of the camera sensor.\n"
		"Number of taps of the camera sensor.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **One** (Display string: 'One'): 1 tap.\n"
		"- **Two** (Display string: 'Two'): 2 taps.\n"
		"- **Three** (Display string: 'Three'): 3 taps.\n"
		"- **Four** (Display string: 'Four'): 4 taps.\n"
		"- **Eight** (Display string: 'Eight'): 8 taps.\n"
		"- **Ten** (Display string: 'Ten'): 10 taps.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_sensorDigitizationTaps_get", _wrap_ImageFormatControl_sensorDigitizationTaps_get, METH_O, "\n"
		"An enumerated integer property. Number of digitized samples outputted simultaneously by the camera A/D conversion stage.\n"
		"Number of digitized samples outputted simultaneously by the camera A/D conversion stage.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **One** (Display string: 'One'): 1 tap.\n"
		"- **Two** (Display string: 'Two'): 2 taps.\n"
		"- **Three** (Display string: 'Three'): 3 taps.\n"
		"- **Four** (Display string: 'Four'): 4 taps.\n"
		"- **Eight** (Display string: 'Eight'): 8 taps.\n"
		"- **Ten** (Display string: 'Ten'): 10 taps.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_widthMax_get", _wrap_ImageFormatControl_widthMax_get, METH_O, "\n"
		"An integer property. Maximum width of the image (in pixels).\n"
		"Maximum width of the image (in pixels). The dimension is calculated after horizontal binning, decimation or any other function changing the horizontal dimension of the image.\n"
		""},
	 { "ImageFormatControl_heightMax_get", _wrap_ImageFormatControl_heightMax_get, METH_O, "\n"
		"An integer property. Maximum height of the image (in pixels).\n"
		"Maximum height of the image (in pixels). This dimension is calculated after vertical binning, decimation or any other function changing the vertical dimension of the image.\n"
		""},
	 { "ImageFormatControl_regionSelector_get", _wrap_ImageFormatControl_regionSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the Region of interest to control.\n"
		"Selects the Region of interest to control. The RegionSelector feature allows devices that are able to extract multiple regions out of an image, to configure the features of those individual regions independently.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): Selected features will control all the regions at the same time.\n"
		"- **Region0** (Display string: 'Region 0'): Selected feature will control the region 0.\n"
		"- **Region1** (Display string: 'Region 1'): Selected feature will control the region 1.\n"
		"- **Region2** (Display string: 'Region 2'): Selected feature will control the region 2.\n"
		"- **Scan3dExtraction0** (Display string: 'Scan 3d Extraction 0'): Selected feature will control the Scan3dExtraction0 output Region.\n"
		"- **Scan3dExtraction1** (Display string: 'Scan 3d Extraction 1'): Selected feature will control the Scan3dExtraction1 output Region.\n"
		"- **Scan3dExtraction2** (Display string: 'Scan 3d Extraction 2'): Selected feature will control the Scan3dExtraction2 output Region.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_regionMode_get", _wrap_ImageFormatControl_regionMode_get, METH_O, "\n"
		"An enumerated integer property. Controls if the selected Region of interest is active and streaming.\n"
		"Controls if the selected Region of interest is active and streaming.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Disable the usage of the Region.\n"
		"- **On** (Display string: 'On'): Enable the usage of the Region.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_regionDestination_get", _wrap_ImageFormatControl_regionDestination_get, METH_O, "\n"
		"An enumerated integer property. Control the destination of the selected region.\n"
		"Control the destination of the selected region.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Stream0** (Display string: 'Stream 0'): The destination of the region is the data stream 0.\n"
		"- **Stream1** (Display string: 'Stream 1'): The destination of the region is the data stream 1.\n"
		"- **Stream2** (Display string: 'Stream 2'): The destination of the region is the data stream 2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_regionIDValue_get", _wrap_ImageFormatControl_regionIDValue_get, METH_O, "\n"
		"An integer property. Returns a unique Identifier value that corresponds to the selected Region.\n"
		"Returns a unique Identifier value that corresponds to the selected Region.\n"
		""},
	 { "ImageFormatControl_componentSelector_get", _wrap_ImageFormatControl_componentSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects a component to activate/deactivate its data streaming.\n"
		"Selects a component to activate/deactivate its data streaming.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Intensity** (Display string: 'Intensity'): The acquisition of intensity (monochrome or color) of the visible reflected light is controlled.\n"
		"- **Infrared** (Display string: 'Infrared'): The acquisition of non-visible infrared light is controlled.\n"
		"- **Ultraviolet** (Display string: 'Ultraviolet'): The acquisition of non-visible ultraviolet light is controlled.\n"
		"- **Range** (Display string: 'Range'): The acquisition of range (distance) data is controlled. The data produced may be only range (2.5D) or a point cloud giving the 3D coordinates depending on the Scan3dControl features.\n"
		"- **Reflectance** (Display string: 'Reflectance'): The reflected intensity acquired together with Range in a Linescan3D sensor acquiring a single linescan profile for each exposure of the sensor.\n"
		"- **Confidence** (Display string: 'Confidence'): The acquisition of confidence map of the acquired image is controlled. Confidence data may be binary (0 - invalid) or an integer where 0 is invalid and increasing value is increased confidence in the data in the corresponding pixel. If floating point representation is used the confidence image is normalized to the range [0,1], for integer representation the maximum possible integer represents maximum confidence.\n"
		"- **Scatter** (Display string: 'Scatter'): The acquisition of data measuring how much light is scattered around the reflected light. In processing this is used as an additional intensity image, often together with the standard intensity or reflectance.\n"
		"- **Disparity** (Display string: 'Disparity'): The acquisition of stereo camera disparity data is controlled. Disparity is a more specific range format approximately inversely proportional to distance. Disparity is typically given in pixel units.\n"
		"- **Multispectral** (Display string: 'Multispectral'): The acquisition of multiple spectral bands corresponding to various light wavelengths is controlled.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_componentEnable_get", _wrap_ImageFormatControl_componentEnable_get, METH_O, "\n"
		"A boolean property. Controls if the selected component streaming is active.\n"
		"Controls if the selected component streaming is active.\n"
		""},
	 { "ImageFormatControl_componentIDValue_get", _wrap_ImageFormatControl_componentIDValue_get, METH_O, "\n"
		"An integer property. Returns a unique Identifier value that corresponds to type of the component selected by ComponentSelector.\n"
		"Returns a unique Identifier value that corresponds to type of the component selected by ComponentSelector.\n"
		""},
	 { "ImageFormatControl_groupSelector_get", _wrap_ImageFormatControl_groupSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects a Group of component to control or inquire.\n"
		"Selects a Group of component to control or inquire. The GroupSelector determines which components Group will be used for the selected features.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Group0** (Display string: 'Group 0'): Group 0\n"
		"- **Group1** (Display string: 'Group 1'): Group 1\n"
		"- **Group2** (Display string: 'Group 2'): Group 2\n"
		"- **Group3** (Display string: 'Group 3'): Group 3\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_groupIDValue_get", _wrap_ImageFormatControl_groupIDValue_get, METH_O, "\n"
		"An integer property. Returns a unique Identifier value corresponding to the selected Group of Components.\n"
		"Returns a unique Identifier value corresponding to the selected Group of Components. If no grouping is required, this value should be set to 0.\n"
		""},
	 { "ImageFormatControl_imageComponentSelector_get", _wrap_ImageFormatControl_imageComponentSelector_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated (See ComponentSelector).\n"
		"Deprecated: \n"
		"This feature is deprecated (See ComponentSelector). It was used to select a component.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Intensity** (Display string: 'Intensity'): The acquisition of intensity (monochrome or color) of the visible reflected light is controlled.\n"
		"- **Color** (Display string: 'Color'): The acquisition of color of the reflected light is controlled\n"
		"- **Infrared** (Display string: 'Infrared'): The acquisition of non-visible infrared light is controlled.\n"
		"- **Ultraviolet** (Display string: 'Ultraviolet'): The acquisition of non-visible ultraviolet light is controlled.\n"
		"- **Range** (Display string: 'Range'): The acquisition of range (distance) data is controlled. The data produced may be only range (2.5D) or a point cloud 3D coordinates depending on the Scan3dControl features.\n"
		"- **Confidence** (Display string: 'Confidence'): The acquisition of confidence map of the acquired image is controlled. Confidence data may be binary (0 - invalid) or an integer where 0 is invalid and increasing value is increased confidence in the data in the corresponding pixel. If floating point representation is used the confidence image is normalized to the range [0,1], for integer representation the maximum possible integer represents maximum confidence.\n"
		"- **Scatter** (Display string: 'Scatter'): The acquisition of data measuring how much light is scattered around the reflected light. In processing this is used as an additional intensity image, often together with the standard intensity.\n"
		"- **Disparity** (Display string: 'Disparity'): The acquisition of stereo camera disparity data is controlled. Disparity is a more specific range format approximately inversely proportional to distance. Disparity is typically given in pixel units.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_imageComponentEnable_get", _wrap_ImageFormatControl_imageComponentEnable_get, METH_O, "\n"
		"A boolean property. This feature is deprecated (See ComponentEnable).\n"
		"Deprecated: \n"
		"This feature is deprecated (See ComponentEnable). It was used to control if the selected component streaming is active.\n"
		""},
	 { "ImageFormatControl_width_get", _wrap_ImageFormatControl_width_get, METH_O, "\n"
		"An integer property. Width of the image provided by the device (in pixels).\n"
		"Width of the image provided by the device (in pixels).\n"
		""},
	 { "ImageFormatControl_height_get", _wrap_ImageFormatControl_height_get, METH_O, "\n"
		"An integer property. Height of the image provided by the device (in pixels).\n"
		"Height of the image provided by the device (in pixels).\n"
		""},
	 { "ImageFormatControl_offsetX_get", _wrap_ImageFormatControl_offsetX_get, METH_O, "\n"
		"An integer property. Horizontal offset from the origin to the region of interest (in pixels).\n"
		"Horizontal offset from the origin to the region of interest (in pixels).\n"
		""},
	 { "ImageFormatControl_offsetY_get", _wrap_ImageFormatControl_offsetY_get, METH_O, "\n"
		"An integer property. Vertical offset from the origin to the region of interest (in pixels).\n"
		"Vertical offset from the origin to the region of interest (in pixels).\n"
		""},
	 { "ImageFormatControl_mvBlockscanLinesPerBlock_get", _wrap_ImageFormatControl_mvBlockscanLinesPerBlock_get, METH_O, "\n"
		"An integer property. Blockscan mode only: Number of lines per block.\n"
		"Blockscan mode only: Number of lines per block.\n"
		""},
	 { "ImageFormatControl_mvBlockscanBlockCount_get", _wrap_ImageFormatControl_mvBlockscanBlockCount_get, METH_O, "\n"
		"An integer property. Blockscan mode only: Number of blocks combined to one frame.\n"
		"Blockscan mode only: Number of blocks combined to one frame\n"
		""},
	 { "ImageFormatControl_mvMultiAreaMode_get", _wrap_ImageFormatControl_mvMultiAreaMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the overall multi area mode.\n"
		"Selects the overall multi area mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvOff** (Display string: 'mv Off'): Multi area mode is altogether switched off. Only one single AOI as defined in Width, Height, OffsetX and OffsetY properties is used and valid.\n"
		"- **mvMultiAreasCombined** (Display string: 'mv Multi Areas Combined'): Image is combined from multiple areas. The overlapping of areas is allowed. The camera decides which areas it needs to crop from the image and combines all areas into one image.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_mvAreaSelector_get", _wrap_ImageFormatControl_mvAreaSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the area in multi area context.\n"
		"Selects the area in multi area context.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvArea0** (Display string: 'mv Area 0'): First area in multi area context.\n"
		"- **mvArea1** (Display string: 'mv Area 1'): Second area in multi area context.\n"
		"- **mvArea2** (Display string: 'mv Area 2'): Third area in multi area context.\n"
		"- **mvArea3** (Display string: 'mv Area 3'): Fourth area in multi area context.\n"
		"- **mvArea4** (Display string: 'mv Area 4'): Fifth area in multi area context.\n"
		"- **mvArea5** (Display string: 'mv Area 5'): Sixth area in multi area context.\n"
		"- **mvArea6** (Display string: 'mv Area 6'): Seventh area in multi area context.\n"
		"- **mvArea7** (Display string: 'mv Area 7'): Eighth area in multi area context.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_mvAreaEnable_get", _wrap_ImageFormatControl_mvAreaEnable_get, METH_O, "\n"
		"A boolean property. This feature controls whether the selected area is active during streaming or not.\n"
		"This feature controls whether the selected area is active during streaming or not.\n"
		""},
	 { "ImageFormatControl_mvAreaWidth_get", _wrap_ImageFormatControl_mvAreaWidth_get, METH_O, "\n"
		"An integer property. Width of this area's part of the image (in pixels).\n"
		"Width of this area's part of the image (in pixels).\n"
		""},
	 { "ImageFormatControl_mvAreaHeight_get", _wrap_ImageFormatControl_mvAreaHeight_get, METH_O, "\n"
		"An integer property. Height of this area's part of the image (in pixels).\n"
		"Height of this area's part of the image (in pixels).\n"
		""},
	 { "ImageFormatControl_mvAreaOffsetX_get", _wrap_ImageFormatControl_mvAreaOffsetX_get, METH_O, "\n"
		"An integer property. Horizontal offset of this area within the image (in pixels).\n"
		"Horizontal offset of this area within the image (in pixels).\n"
		""},
	 { "ImageFormatControl_mvAreaOffsetY_get", _wrap_ImageFormatControl_mvAreaOffsetY_get, METH_O, "\n"
		"An integer property. Vertical offset of this area within the image (in pixels).\n"
		"Vertical offset of this area within the image (in pixels).\n"
		""},
	 { "ImageFormatControl_mvAreaResultingOffsetX_get", _wrap_ImageFormatControl_mvAreaResultingOffsetX_get, METH_O, "\n"
		"An integer property. Horizontal offset of this area within the resulting image (in pixels).\n"
		"Horizontal offset of this area within the resulting image (in pixels).\n"
		""},
	 { "ImageFormatControl_mvAreaResultingOffsetY_get", _wrap_ImageFormatControl_mvAreaResultingOffsetY_get, METH_O, "\n"
		"An integer property. Vertical offset of this area within the resulting image (in pixels).\n"
		"Vertical offset of this area within the resulting image (in pixels).\n"
		""},
	 { "ImageFormatControl_linePitchEnable_get", _wrap_ImageFormatControl_linePitchEnable_get, METH_O, "\n"
		"A boolean property. This feature controls whether the LinePitch feature is writable.\n"
		"This feature controls whether the LinePitch feature is writable. Otherwise LinePitch is implicitly controlled by the combination of features like Width, PixelFormat, etc...\n"
		""},
	 { "ImageFormatControl_linePitch_get", _wrap_ImageFormatControl_linePitch_get, METH_O, "\n"
		"An integer property. Total number of bytes between the starts of 2 consecutive lines.\n"
		"Total number of bytes between the starts of 2 consecutive lines. This feature is used to facilitate alignment of image data.\n"
		""},
	 { "ImageFormatControl_binningSelector_get", _wrap_ImageFormatControl_binningSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which binning engine is controlled by the BinningHorizontal and BinningVertical features.\n"
		"Selects which binning engine is controlled by the BinningHorizontal and BinningVertical features.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Region0** (Display string: 'Region 0'): Selected feature will control the region 0 binning.\n"
		"- **Region1** (Display string: 'Region 1'): Selected feature will control the region 1 binning.\n"
		"- **Region2** (Display string: 'Region 2'): Selected feature will control the region 2 binning.\n"
		"- **Sensor** (Display string: 'Sensor'): Selected features will control the sensor binning.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_binningHorizontalMode_get", _wrap_ImageFormatControl_binningHorizontalMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the mode to use to combine horizontal photo-sensitive cells together when BinningHorizontal is used.\n"
		"Sets the mode to use to combine horizontal photo-sensitive cells together when BinningHorizontal is used.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Sum** (Display string: 'Sum'): The response from the combined cells will be added, resulting in increased sensitivity.\n"
		"- **Average** (Display string: 'Average'): The response from the combined cells will be averaged, resulting in increased signal/noise ratio.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_binningHorizontal_get", _wrap_ImageFormatControl_binningHorizontal_get, METH_O, "\n"
		"An integer property. Number of horizontal photo-sensitive cells to combine together.\n"
		"Number of horizontal photo-sensitive cells to combine together. This reduces the horizontal resolution (width) of the image.\n"
		""},
	 { "ImageFormatControl_binningVerticalMode_get", _wrap_ImageFormatControl_binningVerticalMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the mode to use to combine vertical photo-sensitive cells together when BinningVertical is used.\n"
		"Sets the mode to use to combine vertical photo-sensitive cells together when BinningVertical is used.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Sum** (Display string: 'Sum'): The response from the combined cells will be added, resulting in increased sensitivity.\n"
		"- **Average** (Display string: 'Average'): The response from the combined cells will be averaged, resulting in increased signal/noise ratio.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_binningVertical_get", _wrap_ImageFormatControl_binningVertical_get, METH_O, "\n"
		"An integer property. Number of vertical photo-sensitive cells to combine together.\n"
		"Number of vertical photo-sensitive cells to combine together. This reduces the vertical resolution (height) of the image.\n"
		""},
	 { "ImageFormatControl_decimationHorizontalMode_get", _wrap_ImageFormatControl_decimationHorizontalMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the mode used to reduce the horizontal resolution when DecimationHorizontal is used.\n"
		"Sets the mode used to reduce the horizontal resolution when DecimationHorizontal is used.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Discard** (Display string: 'Discard'): The value of every Nth pixel is kept, others are discarded.\n"
		"- **Average** (Display string: 'Average'): The values of a group of N adjacent pixels are averaged.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_decimationHorizontal_get", _wrap_ImageFormatControl_decimationHorizontal_get, METH_O, "\n"
		"An integer property. Horizontal sub-sampling of the image.\n"
		"Horizontal sub-sampling of the image. This reduces the horizontal resolution (width) of the image by the specified horizontal decimation factor.\n"
		""},
	 { "ImageFormatControl_decimationVerticalMode_get", _wrap_ImageFormatControl_decimationVerticalMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the mode used to reduce the Vertical resolution when DecimationVertical is used.\n"
		"Sets the mode used to reduce the Vertical resolution when DecimationVertical is used.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Discard** (Display string: 'Discard'): The value of every Nth pixel is kept, others are discarded.\n"
		"- **Average** (Display string: 'Average'): The values of a group of N adjacent pixels are averaged.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_decimationVertical_get", _wrap_ImageFormatControl_decimationVertical_get, METH_O, "\n"
		"An integer property. Vertical sub-sampling of the image.\n"
		"Vertical sub-sampling of the image. This reduces the vertical resolution (height) of the image by the specified vertical decimation factor.\n"
		""},
	 { "ImageFormatControl_reverseX_get", _wrap_ImageFormatControl_reverseX_get, METH_O, "\n"
		"A boolean property. Flip horizontally the image sent by the device.\n"
		"Flip horizontally the image sent by the device. The Region of interest is applied after the flipping.\n"
		""},
	 { "ImageFormatControl_reverseY_get", _wrap_ImageFormatControl_reverseY_get, METH_O, "\n"
		"A boolean property. Flip vertically the image sent by the device.\n"
		"Flip vertically the image sent by the device. The Region of interest is applied after the flipping.\n"
		""},
	 { "ImageFormatControl_pixelFormat_get", _wrap_ImageFormatControl_pixelFormat_get, METH_O, "\n"
		"An enumerated integer property. Format of the pixels provided by the device.\n"
		"Format of the pixels provided by the device. It represents all the information provided by PixelSize, PixelColorFilter combined in a single feature.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Mono1p** (Display string: 'Mono1p'): Mono 1 bit packed.\n"
		"- **Mono2p** (Display string: 'Mono2p'): Mono 2 bit packed.\n"
		"- **Mono4p** (Display string: 'Mono4p'): Mono 4 bit packed.\n"
		"- **Mono8** (Display string: 'Mono8'): Mono 8 bit packed.\n"
		"- **Mono8s** (Display string: 'Mono8s'): Mono 1 bit signed.\n"
		"- **Mono10** (Display string: 'Mono10'): Mono 10 bit.\n"
		"- **Mono10p** (Display string: 'Mono10p'): Mono 10 bit packed.\n"
		"- **Mono12** (Display string: 'Mono12'): Mono 12 bit.\n"
		"- **Mono12p** (Display string: 'Mono12p'): Mono 12 bit packed.\n"
		"- **Mono14** (Display string: 'Mono14'): Mono 14 bit.\n"
		"- **Mono16** (Display string: 'Mono16'): Mono 16 bit.\n"
		"- **R8** (Display string: 'R8'): Red 8 bit.\n"
		"- **G8** (Display string: 'G8'): Green 8 bit.\n"
		"- **B8** (Display string: 'B8'): Blue 8 bit.\n"
		"- **RGB8** (Display string: 'RGB8'): Red, Green, Blue 8 bit\n"
		"- **RGB8_Planar** (Display string: 'RGB8_Planar'): Red, Green, Blue 8 bit planar.\n"
		"- **RGBa8** (Display string: 'RGBa8'): Red, Green, Blue 8 bit aligned on 8 bit\n"
		"- **RGB10** (Display string: 'RGB10'): Red, Green, Blue 10 bit.\n"
		"- **RGB10_Planar** (Display string: 'RGB10_Planar'): Red, Green, Blue 10 bit planar.\n"
		"- **RGB10p32** (Display string: 'RGB10p32'): Red, Green, Blue 10 bit packed in 32 bit pixel.\n"
		"- **RGB12** (Display string: 'RGB12'): Red, Green, Blue 12 bit.\n"
		"- **RGB12_Planar** (Display string: 'RGB12_Planar'): Red, Green, Blue 12 bit planar.\n"
		"- **RGB16** (Display string: 'RGB16'): Red, Green, Blue 16 bit.\n"
		"- **RGB16_Planar** (Display string: 'RGB16_Planar'): Red, Green, Blue 16 bit planar.\n"
		"- **RGB565p** (Display string: 'RGB565p'): Red, Green, Blue 16 bit packet in 5, 6, 5 bits.\n"
		"- **BGR10** (Display string: 'BGR10'): Blue, Green, Red, 10 bit.\n"
		"- **BGR12** (Display string: 'BGR12'): Blue, Green, Red, 12 bit.\n"
		"- **BGR16** (Display string: 'BGR16'): Blue, Green, Red, 16 bit.\n"
		"- **BGR565p** (Display string: 'BGR565p'): Blue, Green, Red, 16 bit packet in 5, 6, 5 bits.\n"
		"- **BGR8** (Display string: 'BGR8'): Blue, Green, Red, 8 bit.\n"
		"- **BGRa8** (Display string: 'BGRa8'): Blue, Green, Red, Alpha 8 bit.\n"
		"- **YUV422_8** (Display string: 'YUV422_8'): YUV 422 8 bit.\n"
		"- **YCbCr411_8** (Display string: 'YCbCr411_8'): YCrCb 411 8 bit.\n"
		"- **YCbCr422_8** (Display string: 'YCbCr422_8'): YCrCb 422 8 bit.\n"
		"- **YCbCr601_422_8** (Display string: 'YCbCr601_422_8'): YCrCb 601 422 8 bit.\n"
		"- **YCbCr709_422_8** (Display string: 'YCbCr709_422_8'): YCrCb 709 422 8 bit.\n"
		"- **YCbCr8** (Display string: 'YCbCr8'): YCbCr 8 bit.\n"
		"- **BayerBG8** (Display string: 'BayerBG8'): Bayer Blue Green 8 bit.\n"
		"- **BayerGB8** (Display string: 'BayerGB8'): Bayer Green Blue 8 bit.\n"
		"- **BayerGR8** (Display string: 'BayerGR8'): Bayer Green Red 8 bit.\n"
		"- **BayerRG8** (Display string: 'BayerRG8'): Bayer Red Green 8 bit.\n"
		"- **BayerBG10** (Display string: 'BayerBG10'): Bayer Blue Green 10 bit.\n"
		"- **BayerGB10** (Display string: 'BayerGB10'): Bayer Green Blue 10 bit.\n"
		"- **BayerGR10** (Display string: 'BayerGR10'): Bayer Green Red 10 bit.\n"
		"- **BayerRG10** (Display string: 'BayerRG10'): Bayer Red Green 10 bit.\n"
		"- **BayerBG12** (Display string: 'BayerBG12'): Bayer Blue Green 12 bit\n"
		"- **BayerGB12** (Display string: 'BayerGB12'): Bayer Green Blue 12 bit\n"
		"- **BayerGR12** (Display string: 'BayerGR12'): Bayer Green Red 12 bit.\n"
		"- **BayerRG12** (Display string: 'BayerRG12'): Bayer Red Green 12 bit.\n"
		"- **BayerBG16** (Display string: 'BayerBG16'): Bayer Blue Green 16 bit.\n"
		"- **BayerGB16** (Display string: 'BayerGB16'): Bayer Green Blue 16 bit.\n"
		"- **BayerGR16** (Display string: 'BayerGR16'): Bayer Green Red 16 bit.\n"
		"- **BayerRG16** (Display string: 'BayerRG16'): Bayer Red Green 16 bit.\n"
		"- **Coord3D_A8** (Display string: 'Coord3D_A8'): 3D coordinate, first component 8 bit.\n"
		"- **Coord3D_B8** (Display string: 'Coord3D_B8'): 3D coordinate, second component 8 bit.\n"
		"- **Coord3D_C8** (Display string: 'Coord3D_C8'): 3D coordinate, third component 8 bit.\n"
		"- **Coord3D_ABC8** (Display string: 'Coord3D_ABC8'): 3D coordinates, 3 components 8 bit.\n"
		"- **Coord3D_ABC8_Planar** (Display string: 'Coord3D_ABC8_Planar'): 3D coordinates, 3 components 8 bit planar.\n"
		"- **Coord3D_A16** (Display string: 'Coord3D_A16'): 3D coordinate, first component 16 bit.\n"
		"- **Coord3D_B16** (Display string: 'Coord3D_B16'): 3D coordinate, second component 16 bit.\n"
		"- **Coord3D_C16** (Display string: 'Coord3D_C16'): 3D coordinate, third component 16 bit.\n"
		"- **Coord3D_ABC16** (Display string: 'Coord3D_ABC16'): 3D coordinates, 3 components 16 bit.\n"
		"- **Coord3D_ABC16_Planar** (Display string: 'Coord3D_ABC16_Planar'): 3D coordinates, 3 components 16 bit planar.\n"
		"- **Coord3D_A32f** (Display string: 'Coord3D_A32f'): 3D coordinate, first component 32 bit float.\n"
		"- **Coord3D_B32f** (Display string: 'Coord3D_B32f'): 3D coordinate, second component 32 bit float.\n"
		"- **Coord3D_C32f** (Display string: 'Coord3D_C32f'): 3D coordinate, third component 32 bit float.\n"
		"- **Coord3D_ABC32f** (Display string: 'Coord3D_ABC32f'): 3D coordinates, 3 components 32 bit float.\n"
		"- **Coord3D_ABC32f_Planar** (Display string: 'Coord3D_ABC32f_Planar'): 3D coordinates, 3 components 32 bit float planar.\n"
		"- **Confidence1** (Display string: 'Confidence1'): Confidence data 1 bit.\n"
		"- **Confidence1p** (Display string: 'Confidence1p'): Confidence data 1 bit packed.\n"
		"- **Confidence8** (Display string: 'Confidence8'): Confidence data 8 bit.\n"
		"- **Confidence16** (Display string: 'Confidence16'): Confidence data 16 bit.\n"
		"- **Confidence32f** (Display string: 'Confidence32f'): Confidence data 32 bit float.\n"
		"- **Data8** (Display string: 'Data8'): Generic non-pixel data 8 bit.\n"
		"- **Data8s** (Display string: 'Data8s'): Generic non-pixel data 8 bit signed.\n"
		"- **Data16** (Display string: 'Data16'): Generic non-pixel data 16 bit.\n"
		"- **Data16s** (Display string: 'Data16s'): Generic non-pixel data 16 bit signed.\n"
		"- **Data32** (Display string: 'Data32'): Generic non-pixel data 32 bit.\n"
		"- **Data32s** (Display string: 'Data32s'): Generic non-pixel data 32 bit signed.\n"
		"- **Data32f** (Display string: 'Data32f'): Generic non-pixel data 32 bit floating point.\n"
		"- **Data64** (Display string: 'Data64'): Generic non-pixel data 64 bit.\n"
		"- **Data64s** (Display string: 'Data64s'): Generic non-pixel data 64 bit signed.\n"
		"- **Data64f** (Display string: 'Data64f'): Generic non-pixel data 64 bit floating point.\n"
		"- **Raw8** (Display string: 'Raw8'): Raw 8 bit.\n"
		"- **Raw16** (Display string: 'Raw16'): Raw 16 bit.\n"
		"- **Mono12Packed** (Display string: 'Mono12Packed'): Mono 12 bit packed (GigE Vision Specific).\n"
		"- **BayerGR10Packed** (Display string: 'BayerGR10Packed'): Bayer GR 10 bit packed (GigE Vision Specific).\n"
		"- **BayerRG10Packed** (Display string: 'BayerRG10Packed'): Bayer RG 10 bit packed (GigE Vision Specific).\n"
		"- **BayerGB10Packed** (Display string: 'BayerGB10Packed'): Bayer GB 10 bit packed (GigE Vision Specific).\n"
		"- **BayerBG10Packed** (Display string: 'BayerBG10Packed'): Bayer BG 10 bit packed (GigE Vision Specific).\n"
		"- **BayerGR12Packed** (Display string: 'BayerGR12Packed'): Bayer GR 12 bit packed (GigE Vision Specific).\n"
		"- **BayerRG12Packed** (Display string: 'BayerRG12Packed'): Bayer RG 12 bit packed (GigE Vision Specific).\n"
		"- **BayerGB12Packed** (Display string: 'BayerGB12Packed'): Bayer GB 12 bit packed (GigE Vision Specific).\n"
		"- **BayerBG12Packed** (Display string: 'BayerBG12Packed'): Bayer BG 12 bit packed (GigE Vision Specific).\n"
		"- **RGB10V1Packed** (Display string: 'RGB10V1Packed'): RGB 10 bit packed (GigE Vision Specific).\n"
		"- **RGB12V1Packed** (Display string: 'RGB12V1Packed'): RGB 12 bit packed (GigE Vision Specific).\n"
		"- **Mono8Signed** (Display string: 'Mono 8 Signed')\n"
		"- **Mono10Packed** (Display string: 'Mono 10 Packed')\n"
		"- **RGB8Packed** (Display string: 'RGB 8 Packed')\n"
		"- **BGR8Packed** (Display string: 'BGR 8 Packed')\n"
		"- **RGBA8Packed** (Display string: 'RGBA 8 Packed')\n"
		"- **BGRA8Packed** (Display string: 'BGRA 8 Packed')\n"
		"- **RGB10Packed** (Display string: 'RGB 10 Packed')\n"
		"- **BGR10Packed** (Display string: 'BGR 10 Packed')\n"
		"- **RGB12Packed** (Display string: 'RGB 12 Packed')\n"
		"- **BGR12Packed** (Display string: 'BGR 12 Packed')\n"
		"- **RGB16Packed** (Display string: 'RGB 16 Packed')\n"
		"- **RGB10V2Packed** (Display string: 'RGB 10 V 2 Packed')\n"
		"- **RGB565Packed** (Display string: 'RGB 565 Packed')\n"
		"- **BGR565Packed** (Display string: 'BGR 565 Packed')\n"
		"- **YUV411Packed** (Display string: 'YUV 411 Packed')\n"
		"- **YUV422Packed** (Display string: 'YUV 422 Packed')\n"
		"- **YUV444Packed** (Display string: 'YUV 444 Packed')\n"
		"- **YUYVPacked** (Display string: 'YUYV Packed')\n"
		"- **RGB8Planar** (Display string: 'RGB 8 Planar')\n"
		"- **RGB10Planar** (Display string: 'RGB 10 Planar')\n"
		"- **RGB12Planar** (Display string: 'RGB 12 Planar')\n"
		"- **RGB16Planar** (Display string: 'RGB 16 Planar')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_pixelFormatInfoSelector_get", _wrap_ImageFormatControl_pixelFormatInfoSelector_get, METH_O, "\n"
		"An enumerated integer property. Select the pixel format for which the information will be returned.\n"
		"Select the pixel format for which the information will be returned.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Mono1p** (Display string: 'Mono1p'): Mono 1 bit packed.\n"
		"- **Mono2p** (Display string: 'Mono2p'): Mono 2 bit packed.\n"
		"- **Mono4p** (Display string: 'Mono4p'): Mono 4 bit packed.\n"
		"- **Mono8** (Display string: 'Mono8'): Mono 8 bit packed.\n"
		"- **Mono10** (Display string: 'Mono10'): Mono 10 bit.\n"
		"- **Mono10p** (Display string: 'Mono10p'): Mono 10 bit packed.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_pixelFormatInfoID_get", _wrap_ImageFormatControl_pixelFormatInfoID_get, METH_O, "\n"
		"An integer property. Returns the value used by the streaming channels to identify the selected pixel format.\n"
		"Returns the value used by the streaming channels to identify the selected pixel format.\n"
		""},
	 { "ImageFormatControl_pixelCoding_get", _wrap_ImageFormatControl_pixelCoding_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated.\n"
		"Deprecated: \n"
		"This feature is deprecated. It represents the coding of the pixels in the image. Raw gives the data in the native format of the sensor.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Mono** (Display string: 'Mono'): Mono.\n"
		"- **MonoSigned** (Display string: 'MonoSigned'): Mono signed.\n"
		"- **MonoPacked** (Display string: 'MonoPacked'): Mono packed.\n"
		"- **RGBPacked** (Display string: 'RGBPacked'): RGB packed.\n"
		"- **BGRPacked** (Display string: 'BGRPacked'): BGR packed.\n"
		"- **RGBAPacked** (Display string: 'RGBAPacked'): RGBA packed.\n"
		"- **BGRAPacked** (Display string: 'BGRAPacked'): BGRA packed.\n"
		"- **RGBPlanar** (Display string: 'RGBPlanar'): RGB planar.\n"
		"- **YUV411Packed** (Display string: 'YUV411Packed'): YUV 411 packed.\n"
		"- **YUV422Packed** (Display string: 'YUV422Packed'): YUV 422 packed.\n"
		"- **YUV444Packed** (Display string: 'YUV444Packed'): YUV 444 packed.\n"
		"- **YUYVPacked** (Display string: 'YUYVPacked'): YUYV packed.\n"
		"- **Raw** (Display string: 'Raw'): Raw.\n"
		"- **RawPacked** (Display string: 'RawPacked'): Raw packed.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_pixelSize_get", _wrap_ImageFormatControl_pixelSize_get, METH_O, "\n"
		"An enumerated integer property. Total size in bits of a pixel of the image.\n"
		"Total size in bits of a pixel of the image.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Bpp1** (Display string: 'Bpp1'): 1 bit per pixel.\n"
		"- **Bpp2** (Display string: 'Bpp2'): 2 bits per pixel.\n"
		"- **Bpp4** (Display string: 'Bpp4'): 4 bits per pixel.\n"
		"- **Bpp8** (Display string: 'Bpp8'): 8 bits per pixel.\n"
		"- **Bpp10** (Display string: 'Bpp10'): 10 bits per pixel.\n"
		"- **Bpp12** (Display string: 'Bpp12'): 12 bits per pixel.\n"
		"- **Bpp14** (Display string: 'Bpp14'): 14 bits per pixel.\n"
		"- **Bpp16** (Display string: 'Bpp16'): 16 bits per pixel.\n"
		"- **Bpp20** (Display string: 'Bpp20'): 20 bits per pixel.\n"
		"- **Bpp24** (Display string: 'Bpp24'): 24 bits per pixel.\n"
		"- **Bpp30** (Display string: 'Bpp30'): 30 bits per pixel.\n"
		"- **Bpp32** (Display string: 'Bpp32'): 32 bits per pixel.\n"
		"- **Bpp36** (Display string: 'Bpp36'): 36 bits per pixel.\n"
		"- **Bpp48** (Display string: 'Bpp48'): 48 bits per pixel.\n"
		"- **Bpp64** (Display string: 'Bpp64'): 64 bits per pixel.\n"
		"- **Bpp96** (Display string: 'Bpp96'): 96 bits per pixel.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_pixelColorFilter_get", _wrap_ImageFormatControl_pixelColorFilter_get, METH_O, "\n"
		"An enumerated integer property. Type of color filter that is applied to the image.\n"
		"Type of color filter that is applied to the image.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **None** (Display string: 'None'): No color filter.\n"
		"- **BayerRG** (Display string: 'BayerRG'): Bayer Red Green filter.\n"
		"- **BayerGB** (Display string: 'BayerGB'): Bayer Green Blue filter.\n"
		"- **BayerGR** (Display string: 'BayerGR'): Bayer Green Red filter.\n"
		"- **BayerBG** (Display string: 'BayerBG'): Bayer Blue Green filter.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_pixelDynamicRangeMin_get", _wrap_ImageFormatControl_pixelDynamicRangeMin_get, METH_O, "\n"
		"An integer property. Minimum value that can be returned during the digitization process.\n"
		"Minimum value that can be returned during the digitization process. This corresponds to the darkest value of the camera. For color camera, this returns the smallest value that each color component can take.\n"
		""},
	 { "ImageFormatControl_pixelDynamicRangeMax_get", _wrap_ImageFormatControl_pixelDynamicRangeMax_get, METH_O, "\n"
		"An integer property. Maximum value that will be returned during the digitization process.\n"
		"Maximum value that will be returned during the digitization process. This corresponds to the brightest value of the camera. For color camera, this returns the biggest value that each color component can take.\n"
		""},
	 { "ImageFormatControl_testPatternGeneratorSelector_get", _wrap_ImageFormatControl_testPatternGeneratorSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which test pattern generator is controlled by the TestPattern feature.\n"
		"Selects which test pattern generator is controlled by the TestPattern feature.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Region0** (Display string: 'Region 0'): TestPattern feature will control the region 0 test pattern generator.\n"
		"- **Region1** (Display string: 'Region 1'): TestPattern feature will control the region 1 test pattern generator.\n"
		"- **Region2** (Display string: 'Region 2'): TestPattern feature will control the region 2 test pattern generator.\n"
		"- **Sensor** (Display string: 'Sensor'): TestPattern feature will control the sensor's test pattern generator.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_testPattern_get", _wrap_ImageFormatControl_testPattern_get, METH_O, "\n"
		"An enumerated integer property. Selects the type of test pattern that is generated by the device as image source.\n"
		"Selects the type of test pattern that is generated by the device as image source.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Image is coming from the sensor.\n"
		"- **Black** (Display string: 'Black'): Image is filled with the darkest possible image.\n"
		"- **White** (Display string: 'White'): Image is filled with the brightest possible image.\n"
		"- **GreyHorizontalRamp** (Display string: 'Grey Horizontal Ramp'): Image is filled horizontally with an image that goes from the darkest possible value to the brightest.\n"
		"- **GreyVerticalRamp** (Display string: 'Grey Vertical Ramp'): Image is filled vertically with an image that goes from the darkest possible value to the brightest.\n"
		"- **GreyHorizontalRampMoving** (Display string: 'Grey Horizontal Ramp Moving'): Image is filled horizontally with an image that goes from the darkest possible value to the brightest and that moves horizontally from left to right at each frame.\n"
		"- **GreyVerticalRampMoving** (Display string: 'Grey Vertical Ramp Moving'): Image is filled vertically with an image that goes from the darkest possible value to the brightest and that moves vertically from top to bottom at each frame.\n"
		"- **HorizontalLineMoving** (Display string: 'Horizontal Line Moving'): A moving horizontal line is superimposed on the live image.\n"
		"- **VerticalLineMoving** (Display string: 'Vertical Line Moving'): A moving vertical line is superimposed on the live image.\n"
		"- **ColorBar** (Display string: 'Color Bar'): Image is filled with stripes of color including White, Black, Red, Green, Blue, Cyan, Magenta and Yellow.\n"
		"- **FrameCounter** (Display string: 'Frame Counter'): A frame counter is superimposed on the live image.\n"
		"- **HorzontalLineMoving** (Display string: 'Horzontal Line Moving')\n"
		"- **mvBayerRaw** (Display string: 'mv Bayer Raw')\n"
		"- **mvGreyDiagonalRamp** (Display string: 'mv Grey Diagonal Ramp')\n"
		"- **mvFadeToGreyColorBar** (Display string: 'mv Fade To Grey Color Bar')\n"
		"- **mvFFCImage** (Display string: 'mv FFC Image')\n"
		"- **mvMovingGreyDiagonalRamp** (Display string: 'mv Moving Grey Diagonal Ramp')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_testImageSelector_get", _wrap_ImageFormatControl_testImageSelector_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated (See TestPattern).\n"
		"Deprecated: \n"
		"This feature is deprecated (See TestPattern). Selects the type of test image that is sent by the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Image is coming from the sensor.\n"
		"- **Black** (Display string: 'Black'): Image is filled with the darkest possible image.\n"
		"- **White** (Display string: 'White'): Image is filled with the brightest possible image.\n"
		"- **GreyHorizontalRamp** (Display string: 'Grey Horizontal Ramp'): Image is filled horizontally with an image that goes from the darkest possible value to the brightest.\n"
		"- **GreyVerticalRamp** (Display string: 'Grey Vertical Ramp'): Image is filled vertically with an image that goes from the darkest possible value to the brightest.\n"
		"- **GreyHorizontalRampMoving** (Display string: 'Grey Horizontal Ramp Moving'): Image is filled horizontally with an image that goes from the darkest possible value to the brightest and that moves horizontally from left to right at each frame.\n"
		"- **GreyVerticalRampMoving** (Display string: 'Grey Vertical Ramp Moving'): Image is filled vertically with an image that goes from the darkest possible value to the brightest and that moves vertically from top to bottom at each frame.\n"
		"- **HorizontalLineMoving** (Display string: 'Horizontal Line Moving'): A moving horizontal line is superimposed on the live image.\n"
		"- **VerticalLineMoving** (Display string: 'Vertical Line Moving'): A moving vertical line is superimposed on the live image.\n"
		"- **ColorBar** (Display string: 'Color Bar'): Image is filled with stripes of color including White, Black, Red, Green, Blue, Cyan, Magenta and Yellow.\n"
		"- **FrameCounter** (Display string: 'Frame Counter'): A frame counter is superimposed on the live image.\n"
		"- **HorzontalLineMoving** (Display string: 'Horzontal Line Moving')\n"
		"- **mvBayerRaw** (Display string: 'mv Bayer Raw')\n"
		"- **mvGreyDiagonalRamp** (Display string: 'mv Grey Diagonal Ramp')\n"
		"- **mvFadeToGreyColorBar** (Display string: 'mv Fade To Grey Color Bar')\n"
		"- **mvFFCImage** (Display string: 'mv FFC Image')\n"
		"- **mvMovingGreyDiagonalRamp** (Display string: 'mv Moving Grey Diagonal Ramp')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_deinterlacing_get", _wrap_ImageFormatControl_deinterlacing_get, METH_O, "\n"
		"An enumerated integer property. Controls how the device performs de-interlacing.\n"
		"Controls how the device performs de-interlacing.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The device doesn't perform de-interlacing.\n"
		"- **LineDuplication** (Display string: 'Line Duplication'): The device performs de-interlacing by outputting each line of each field twice.\n"
		"- **Weave** (Display string: 'Weave'): The device performs de-interlacing by interleaving the lines of all fields.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_imageCompressionMode_get", _wrap_ImageFormatControl_imageCompressionMode_get, METH_O, "\n"
		"An enumerated integer property. Enable a specific image compression mode as the base mode for image transfer.\n"
		"Enable a specific image compression mode as the base mode for image transfer.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Default value. Image compression is disabled. Images are transmitted uncompressed.\n"
		"- **JPEG** (Display string: 'JPEG'): JPEG compression is selected.\n"
		"- **JPEG2000** (Display string: 'JPEG 2000'): JPEG 2000 compression is selected.\n"
		"- **H264** (Display string: 'H 264'): H.264 compression is selected.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_imageCompressionRateOption_get", _wrap_ImageFormatControl_imageCompressionRateOption_get, METH_O, "\n"
		"An enumerated integer property. Two rate controlling options are offered: fixed bit rate or fixed quality.\n"
		"Two rate controlling options are offered: fixed bit rate or fixed quality. The exact implementation to achieve one or the other is vendor-specific.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **FixBitrate** (Display string: 'Fix Bitrate'): Output stream follows a constant bit rate. Allows easy bandwidth management on the link.\n"
		"- **FixQuality** (Display string: 'Fix Quality'): Output stream has a constant image quality. Can be used when image processing algorithms are sensitive to image degradation caused by excessive data compression.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_imageCompressionQuality_get", _wrap_ImageFormatControl_imageCompressionQuality_get, METH_O, "\n"
		"An integer property. Control the quality of the produced compressed stream.\n"
		"Control the quality of the produced compressed stream.\n"
		""},
	 { "ImageFormatControl_imageCompressionBitrate_get", _wrap_ImageFormatControl_imageCompressionBitrate_get, METH_O, "\n"
		"A floating point property. Control the rate of the produced compressed stream.\n"
		"Control the rate of the produced compressed stream.\n"
		""},
	 { "ImageFormatControl_imageCompressionJPEGFormatOption_get", _wrap_ImageFormatControl_imageCompressionJPEGFormatOption_get, METH_O, "\n"
		"An enumerated integer property. When JPEG is selected as the compression format, a device might optionally offer better control over JPEG-specific options through this feature.\n"
		"When JPEG is selected as the compression format, a device might optionally offer better control over JPEG-specific options through this feature.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Lossless** (Display string: 'Lossless'): Selects lossless JPEG compression based on a predictive coding model.\n"
		"- **BaselineStandard** (Display string: 'Baseline Standard'): Indicates this is a baseline sequential (single-scan) DCT-based JPEG.\n"
		"- **BaselineOptimized** (Display string: 'Baseline Optimized'): Provides optimized color and slightly better compression than baseline standard by using custom Huffman tables optimized after statistical analysis of the image content.\n"
		"- **Progressive** (Display string: 'Progressive'): Indicates this is a progressive (multi-scan) DCT-based JPEG.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_mvSensorDigitizationBitDepth_get", _wrap_ImageFormatControl_mvSensorDigitizationBitDepth_get, METH_O, "\n"
		"An enumerated integer property. This feature manually selects the resolution of the device's ADC.\n"
		"This feature manually selects the resolution of the device's ADC.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Auto** (Display string: 'Auto'): When the selected pixel format has 12 bits or more the ADC will work with 12 bits. Otherwise the ADC will work with 10 bits.\n"
		"- **Bpp8** (Display string: 'Bpp 8'): The ADC will always work with a resolution of  8 bits no matter which pixel format has been selected.\n"
		"- **Bpp10** (Display string: 'Bpp 10'): The ADC will always work with a resolution of 10 bits no matter which pixel format has been selected.\n"
		"- **Bpp12** (Display string: 'Bpp 12'): The ADC will always work with a resolution of 12 bits no matter which pixel format has been selected. This will allow to achieve higher precision and thus improved quality when internal processing is done (e.g. when applying digital gain to the image).\n"
		"- **Fixed** (Display string: 'Fixed')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ImageFormatControl_mvDualAdcMode_get", _wrap_ImageFormatControl_mvDualAdcMode_get, METH_O, "\n"
		"A boolean property. Use this mode for a higher dynamic range. The maximum frame rate will be halved then. Using this mode only makes sense when used with pixel formats >= 14 bits. For mv Gen 4 sensors, both high and low level gain pixels are combined internally in the sensor.\n"
		"Use this mode for a higher dynamic range. The maximum frame rate will be halved then. Using this mode only makes sense when used with pixel formats >= 14 bits.  For mv Gen 4 sensors, both high and low level gain pixels are combined internally in the sensor.\n"
		""},
	 { "ImageFormatControl_mvDualAdcCompression_get", _wrap_ImageFormatControl_mvDualAdcCompression_get, METH_O, "\n"
		"An integer property. After the internal combination of both high and low gain pixels, the output data is compressed to fit 12-bits. This feature sets the compression characteristic of the Dual Adc (different kneepoints of the compression curve). 0 means compression is off.\n"
		"After the internally combination of both high and low gain pixels, the output data is compressed to fit 12-bits. This feature sets the compression characteristic of the Dual Adc (different kneepoints of the compression curve). 0 means compression is off.\n"
		""},
	 { "delete_ImageFormatControl", _wrap_delete_ImageFormatControl, METH_O, NULL},
	 { "ImageFormatControl_swigregister", ImageFormatControl_swigregister, METH_O, NULL},
	 { "ImageFormatControl_swiginit", ImageFormatControl_swiginit, METH_VARARGS, NULL},
	 { "new_AcquisitionControl", _wrap_new_AcquisitionControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::AcquisitionControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "AcquisitionControl_acquisitionMode_get", _wrap_AcquisitionControl_acquisitionMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the acquisition mode of the device.\n"
		"Sets the acquisition mode of the device. It defines mainly the number of frames to capture during an acquisition and the way the acquisition stops.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **SingleFrame** (Display string: 'Single Frame'): One frame is captured.\n"
		"- **MultiFrame** (Display string: 'Multi Frame'): The number of frames specified by AcquisitionFrameCount is captured.\n"
		"- **Continuous** (Display string: 'Continuous'): Frames are captured continuously until stopped with the AcquisitionStop command.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_acquisitionStart_get", _wrap_AcquisitionControl_acquisitionStart_get, METH_O, "\n"
		"A method object. Starts the Acquisition of the device.\n"
		"Starts the Acquisition of the device. The number of frames captured is specified by AcquisitionMode.\n"
		""},
	 { "AcquisitionControl_acquisitionStop_get", _wrap_AcquisitionControl_acquisitionStop_get, METH_O, "\n"
		"A method object. Stops the Acquisition of the device at the end of the current Frame.\n"
		"Stops the Acquisition of the device at the end of the current Frame. It is mainly used when AcquisitionMode is Continuous but can be used in any acquisition mode.\n"
		""},
	 { "AcquisitionControl_acquisitionStopMode_get", _wrap_AcquisitionControl_acquisitionStopMode_get, METH_O, "\n"
		"An enumerated integer property. Controls how the AcquisitionStop command and the acquisition stopped using a trigger (e.g.\n"
		"Controls how the AcquisitionStop command and the acquisition stopped using a trigger (e.g. AcquisitionActive, FrameBurstActive, FrameActive or FrameEnd trigger), ends an ongoing frame. This feature is mainly used in Linescan devices where each line in a frame is acquired sequentially.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Complete** (Display string: 'Complete'): When stopped during a frame, the device will continue acquisition of lines until the specified Height is reached to deliver a complete default size frame. Note that if each line is triggered from an external source and this line trigger stops no frame is delivered, and an AcquisitionAbort is needed.\n"
		"- **Immediate** (Display string: 'Immediate'): Acquisition stops immediately even during a frame and only the lines acquired at the time  are delivered.\n"
		"- **ImmediateWithPadding** (Display string: 'Immediate With Padding'): Acquisition stops immediately even during a frame but the remaining of the frame will be padded with data to deliver a complete default Height frame.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_acquisitionAbort_get", _wrap_AcquisitionControl_acquisitionAbort_get, METH_O, "\n"
		"A method object. Aborts the Acquisition immediately.\n"
		"Aborts the Acquisition immediately. This will end the capture without completing the current Frame or waiting on a trigger. If no Acquisition is in progress, the command is ignored.\n"
		""},
	 { "AcquisitionControl_acquisitionArm_get", _wrap_AcquisitionControl_acquisitionArm_get, METH_O, "\n"
		"A method object. Arms the device before an AcquisitionStart command.\n"
		"Arms the device before an AcquisitionStart command. This optional command validates all the current features for consistency and prepares the device for a fast start of the Acquisition.\n"
		""},
	 { "AcquisitionControl_acquisitionFrameCount_get", _wrap_AcquisitionControl_acquisitionFrameCount_get, METH_O, "\n"
		"An integer property. Number of frames to acquire in MultiFrame Acquisition mode.\n"
		"Number of frames to acquire in MultiFrame Acquisition mode.\n"
		""},
	 { "AcquisitionControl_acquisitionBurstFrameCount_get", _wrap_AcquisitionControl_acquisitionBurstFrameCount_get, METH_O, "\n"
		"An integer property. Number of frames to acquire for each FrameBurstStart trigger.\n"
		"Number of frames to acquire for each FrameBurstStart trigger.\n"
		""},
	 { "AcquisitionControl_mvSensorRegister_get", _wrap_AcquisitionControl_mvSensorRegister_get, METH_O, "\n"
		"An integer property. Number of sensor register to access.\n"
		"Number of sensor register to access.\n"
		""},
	 { "AcquisitionControl_mvSensorRegisterValue_get", _wrap_AcquisitionControl_mvSensorRegisterValue_get, METH_O, "\n"
		"An integer property. Value of sensor register.\n"
		"Value of sensor register.\n"
		""},
	 { "AcquisitionControl_acquisitionFrameRate_get", _wrap_AcquisitionControl_acquisitionFrameRate_get, METH_O, "\n"
		"A floating point property. Controls the acquisition rate (in Hertz) at which the frames are captured.\n"
		"Controls the acquisition rate (in Hertz) at which the frames are captured.\n"
		""},
	 { "AcquisitionControl_acquisitionFrameRateEnable_get", _wrap_AcquisitionControl_acquisitionFrameRateEnable_get, METH_O, "\n"
		"A boolean property. Controls if the AcquisitionFrameRate feature is writable and used to control the acquisition rate.\n"
		"Controls if the AcquisitionFrameRate feature is writable and used to control the acquisition rate. Otherwise, the acquisition rate is implicitly controlled by the combination of other features like ExposureTime, etc...\n"
		""},
	 { "AcquisitionControl_acquisitionLineRate_get", _wrap_AcquisitionControl_acquisitionLineRate_get, METH_O, "\n"
		"A floating point property. Controls the rate (in Hertz) at which the Lines in a Frame are captured.\n"
		"Controls the rate (in Hertz) at which the Lines in a Frame are captured.\n"
		""},
	 { "AcquisitionControl_acquisitionLineRateEnable_get", _wrap_AcquisitionControl_acquisitionLineRateEnable_get, METH_O, "\n"
		"A boolean property. Controls if the AcquisitionLineRate feature is writable and used to control the acquisition rate.\n"
		"Controls if the AcquisitionLineRate feature is writable and used to control the acquisition rate. Otherwise, the acquisition rate is implicitly controlled by the combination of other features like ExposureTime, etc...\n"
		""},
	 { "AcquisitionControl_acquisitionStatusSelector_get", _wrap_AcquisitionControl_acquisitionStatusSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the internal acquisition signal to read using AcquisitionStatus.\n"
		"Selects the internal acquisition signal to read using AcquisitionStatus.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionTriggerWait** (Display string: 'Acquisition Trigger Wait'): Device is currently waiting for a trigger for the capture of one or many frames.\n"
		"- **AcquisitionActive** (Display string: 'Acquisition Active'): Device is currently doing an acquisition of one or many frames.\n"
		"- **AcquisitionTransfer** (Display string: 'Acquisition Transfer'): Device is currently transferring an acquisition of one or many frames.\n"
		"- **FrameTriggerWait** (Display string: 'Frame Trigger Wait'): Device is currently waiting for a frame start trigger.\n"
		"- **FrameActive** (Display string: 'Frame Active'): Device is currently doing the capture of a frame.\n"
		"- **ExposureActive** (Display string: 'Exposure Active'): Device is doing the exposure of a frame.\n"
		"- **FrameTransfer** (Display string: 'Frame Transfer'): See TransferStatus.\n"
		"- **FrameTransfer** (Display string: 'Frame Transfer'): See TransferStatus.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_acquisitionStatus_get", _wrap_AcquisitionControl_acquisitionStatus_get, METH_O, "\n"
		"A boolean property. Reads the state of the internal acquisition signal selected using AcquisitionStatusSelector.\n"
		"Reads the state of the internal acquisition signal selected using AcquisitionStatusSelector.\n"
		""},
	 { "AcquisitionControl_triggerSelector_get", _wrap_AcquisitionControl_triggerSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the type of trigger to configure.\n"
		"Selects the type of trigger to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Selects a trigger that starts the Acquisition of one or many frames according to AcquisitionMode.\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Selects a trigger that ends the Acquisition of one or many frames according to AcquisitionMode.\n"
		"- **AcquisitionActive** (Display string: 'Acquisition Active'): Selects a trigger that controls the duration of the Acquisition of one or many frames. The Acquisition is activated when the trigger signal becomes active and terminated when it goes back to the inactive state.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Selects a trigger starting the capture of one frame.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Selects a trigger ending the capture of one frame (mainly used in linescan mode).\n"
		"- **FrameActive** (Display string: 'Frame Active'): Selects a trigger controlling the duration of one frame (mainly used in linescan mode).\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Selects a trigger starting the capture of the bursts of frames in an acquisition. AcquisitionBurstFrameCount controls the length of each burst unless a FrameBurstEnd trigger is active. The total number of frames captured is also conditioned by AcquisitionFrameCount if AcquisitionMode is MultiFrame.\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Selects a trigger ending the capture of the bursts of frames in an acquisition.\n"
		"- **FrameBurstActive** (Display string: 'Frame Burst Active'): Selects a trigger controlling the duration of the capture of the bursts of frames in an acquisition.\n"
		"- **LineStart** (Display string: 'Line Start'): Selects a trigger starting the capture of one Line of a Frame (mainly used in linescan mode).\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Selects a trigger controlling the start of the exposure of one Frame (or Line).\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Selects a trigger controlling the end of the exposure of one Frame (or Line).\n"
		"- **ExposureActive** (Display string: 'Exposure Active'): Selects a trigger controlling the duration of the exposure of one frame (or Line).\n"
		"- **MultiSlopeExposureLimit1** (Display string: 'Multi Slope Exposure Limit 1'): Selects a trigger controlling the first duration of a multi-slope exposure. Exposure is continued according to the pre-defined multi-slope settings.\n"
		"- **mvTimestampReset** (Display string: 'mv Timestamp Reset')\n"
		"- **mvLoopRecordEnd** (Display string: 'mv Loop Record End')\n"
		"- **mvFrameStartSensor2** (Display string: 'mv Frame Start Sensor 2')\n"
		"- **mvInvalidTriggerSelector** (Display string: 'mv Invalid Trigger Selector')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_triggerMode_get", _wrap_AcquisitionControl_triggerMode_get, METH_O, "\n"
		"An enumerated integer property. Controls if the selected trigger is active.\n"
		"Controls if the selected trigger is active.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Disables the selected trigger.\n"
		"- **On** (Display string: 'On'): Enable the selected trigger.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_triggerSoftware_get", _wrap_AcquisitionControl_triggerSoftware_get, METH_O, "\n"
		"A method object. Generates an internal trigger.\n"
		"Generates an internal trigger. TriggerSource must be set to Software.\n"
		""},
	 { "AcquisitionControl_triggerSource_get", _wrap_AcquisitionControl_triggerSource_get, METH_O, "\n"
		"An enumerated integer property. Specifies the internal signal or physical input Line to use as the trigger source.\n"
		"Specifies the internal signal or physical input Line to use as the trigger source. The selected trigger must have its TriggerMode set to On.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Action0** (Display string: 'Action 0'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action1** (Display string: 'Action 1'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action2** (Display string: 'Action 2'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action3** (Display string: 'Action 3'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action4** (Display string: 'Action 4'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action5** (Display string: 'Action 5'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action6** (Display string: 'Action 6'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action7** (Display string: 'Action 7'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action8** (Display string: 'Action 8'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action9** (Display string: 'Action 9'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action10** (Display string: 'Action 10'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action11** (Display string: 'Action 11'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action12** (Display string: 'Action 12'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action13** (Display string: 'Action 13'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action14** (Display string: 'Action 14'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **Action15** (Display string: 'Action 15'): Specifies which Action command to use as internal source for the trigger.\n"
		"- **CC1** (Display string: 'CC 1'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC2** (Display string: 'CC 2'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC3** (Display string: 'CC 3'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC4** (Display string: 'CC 4'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC5** (Display string: 'CC 5'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC6** (Display string: 'CC 6'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC7** (Display string: 'CC 7'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC8** (Display string: 'CC 8'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC9** (Display string: 'CC 9'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC10** (Display string: 'CC 10'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC11** (Display string: 'CC 11'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC12** (Display string: 'CC 12'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC13** (Display string: 'CC 13'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC14** (Display string: 'CC 14'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC15** (Display string: 'CC 15'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter3Start** (Display string: 'Counter 3 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter4Start** (Display string: 'Counter 4 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter5Start** (Display string: 'Counter 5 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter6Start** (Display string: 'Counter 6 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter7Start** (Display string: 'Counter 7 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter8Start** (Display string: 'Counter 8 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter9Start** (Display string: 'Counter 9 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter10Start** (Display string: 'Counter 10 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter11Start** (Display string: 'Counter 11 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter12Start** (Display string: 'Counter 12 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter13Start** (Display string: 'Counter 13 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter14Start** (Display string: 'Counter 14 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Counter15Start** (Display string: 'Counter 15 Start'): Specifies which of the Counter signal to use as internal source for the trigger.\n"
		"- **Encoder0** (Display string: 'Encoder 0'): Specifies which Encoder signal to use as internal source for the trigger.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): Specifies which Encoder signal to use as internal source for the trigger.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): Specifies which Encoder signal to use as internal source for the trigger.\n"
		"- **Line0** (Display string: 'Line 0'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line1** (Display string: 'Line 1'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line2** (Display string: 'Line 2'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line3** (Display string: 'Line 3'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line4** (Display string: 'Line 4'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line5** (Display string: 'Line 5'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line6** (Display string: 'Line 6'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line7** (Display string: 'Line 7'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line8** (Display string: 'Line 8'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line9** (Display string: 'Line 9'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line10** (Display string: 'Line 10'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line11** (Display string: 'Line 11'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line12** (Display string: 'Line 12'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line13** (Display string: 'Line 13'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line14** (Display string: 'Line 14'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **Line15** (Display string: 'Line 15'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): Specifies which Link Trigger to use as  source for the trigger (received from the transport layer).\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): Specifies which Link Trigger to use as  source for the trigger (received from the transport layer).\n"
		"- **LinkTrigger2** (Display string: 'Link Trigger 2'): Specifies which Link Trigger to use as  source for the trigger (received from the transport layer).\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): Specifies which Logic Block signal to use as internal source for the trigger.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): Specifies which Logic Block signal to use as internal source for the trigger.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): Specifies which Logic Block signal to use as internal source for the trigger.\n"
		"- **Software** (Display string: 'Software'): Specifies that the trigger source will be generated by software using the TriggerSoftware command.\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): Specifies that the trigger source will be a signal generated by software using the SoftwareSignalPulse command.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): Specifies that the trigger source will be a signal generated by software using the SoftwareSignalPulse command.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): Specifies that the trigger source will be a signal generated by software using the SoftwareSignalPulse command.\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer3Start** (Display string: 'Timer 3 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer4Start** (Display string: 'Timer 4 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer5Start** (Display string: 'Timer 5 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer6Start** (Display string: 'Timer 6 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer7Start** (Display string: 'Timer 7 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer8Start** (Display string: 'Timer 8 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer9Start** (Display string: 'Timer 9 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer10Start** (Display string: 'Timer 10 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer11Start** (Display string: 'Timer 11 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer12Start** (Display string: 'Timer 12 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer13Start** (Display string: 'Timer 13 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer14Start** (Display string: 'Timer 14 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **Timer15Start** (Display string: 'Timer 15 Start'): Specifies which Timer signal to use as internal source for the trigger.\n"
		"- **UserOutput0** (Display string: 'User Output 0'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput1** (Display string: 'User Output 1'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput2** (Display string: 'User Output 2'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput3** (Display string: 'User Output 3'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput4** (Display string: 'User Output 4'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput5** (Display string: 'User Output 5'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput6** (Display string: 'User Output 6'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput7** (Display string: 'User Output 7'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput8** (Display string: 'User Output 8'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput9** (Display string: 'User Output 9'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput10** (Display string: 'User Output 10'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput11** (Display string: 'User Output 11'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput12** (Display string: 'User Output 12'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput13** (Display string: 'User Output 13'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput14** (Display string: 'User Output 14'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput15** (Display string: 'User Output 15'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')\n"
		"- **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')\n"
		"- **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')\n"
		"- **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_triggerActivation_get", _wrap_AcquisitionControl_triggerActivation_get, METH_O, "\n"
		"An enumerated integer property. Specifies the activation mode of the trigger.\n"
		"Specifies the activation mode of the trigger.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RisingEdge** (Display string: 'Rising Edge'): Specifies that the trigger is considered valid on the rising edge of the source signal.\n"
		"- **FallingEdge** (Display string: 'Falling Edge'): Specifies that the trigger is considered valid on the falling edge of the source signal.\n"
		"- **AnyEdge** (Display string: 'Any Edge'): Specifies that the trigger is considered valid on the falling or rising edge of the source signal.\n"
		"- **LevelHigh** (Display string: 'Level High'): Specifies that the trigger is considered valid as long as the level of the source signal is high.\n"
		"- **LevelLow** (Display string: 'Level Low'): Specifies that the trigger is considered valid as long as the level of the source signal is low.\n"
		"- **mvNone** (Display string: 'mv None')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_triggerOverlap_get", _wrap_AcquisitionControl_triggerOverlap_get, METH_O, "\n"
		"An enumerated integer property. Specifies the type trigger overlap permitted with the previous frame or line.\n"
		"Specifies the type trigger overlap permitted with the previous frame or line. This defines when a valid trigger will be accepted (or latched) for a new frame or a new line.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): No trigger overlap is permitted.\n"
		"- **ReadOut** (Display string: 'Read Out'): Trigger is accepted immediately after the exposure period.\n"
		"- **PreviousFrame** (Display string: 'Previous Frame'): Trigger is accepted (latched) at any time during the capture of the previous frame.\n"
		"- **PreviousLine** (Display string: 'Previous Line'): Trigger is accepted (latched) at any time during the capture of the previous line.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_triggerDelay_get", _wrap_AcquisitionControl_triggerDelay_get, METH_O, "\n"
		"A floating point property. Specifies the delay in microseconds (us) to apply after the trigger reception before activating it.\n"
		"Specifies the delay in microseconds (us) to apply after the trigger reception before activating it.\n"
		""},
	 { "AcquisitionControl_triggerDivider_get", _wrap_AcquisitionControl_triggerDivider_get, METH_O, "\n"
		"An integer property. Specifies a division factor for the incoming trigger pulses.\n"
		"Specifies a division factor for the incoming trigger pulses.\n"
		""},
	 { "AcquisitionControl_triggerMultiplier_get", _wrap_AcquisitionControl_triggerMultiplier_get, METH_O, "\n"
		"An integer property. Specifies a multiplication factor for the incoming trigger pulses.\n"
		"Specifies a multiplication factor for the incoming trigger pulses. It is generally used in conjunction with TriggerDivider to control the ratio of triggers that are accepted.\n"
		""},
	 { "AcquisitionControl_exposureMode_get", _wrap_AcquisitionControl_exposureMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the operation mode of the Exposure.\n"
		"Sets the operation mode of the Exposure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Disables the Exposure and let the shutter open.\n"
		"- **Timed** (Display string: 'Timed'): Timed exposure. The exposure duration time is set using the ExposureTime or ExposureAuto features and the exposure starts with the FrameStart or LineStart.\n"
		"- **TriggerWidth** (Display string: 'Trigger Width'): Uses the width of the current Frame or Line trigger signal(s) pulse to control the exposure duration. Note that if the Frame or Line TriggerActivation is RisingEdge or LevelHigh, the exposure duration will be the time the trigger stays High. If TriggerActivation is FallingEdge or LevelLow, the exposure time will last as long as the trigger stays Low.\n"
		"- **TriggerControlled** (Display string: 'Trigger Controlled'): Uses one or more trigger signal(s) to control the exposure duration independently from the current Frame or Line triggers. See ExposureStart, ExposureEnd and ExposureActive of the TriggerSelector feature.\n"
		"- **mvMultiZone** (Display string: 'mv Multi Zone'): The exposure duration time can be configured individually for different zones within the image by setting the 'ExposureTimeSelector' to one of the 'mvHorizontalZone' values. This mode will only have effect on the image when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_exposureTimeMode_get", _wrap_AcquisitionControl_exposureTimeMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the configuration mode of the ExposureTime feature.\n"
		"Sets the configuration mode of the ExposureTime feature.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Common** (Display string: 'Common'): The exposure time is common to all the color components. The common ExposureTime value to use can be set selecting it with ExposureTimeSelector[Common].\n"
		"- **Individual** (Display string: 'Individual'): The exposure time is individual for each color component. Each individual ExposureTime values to use can be set by selecting them with ExposureTimeSelector.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_exposureTimeSelector_get", _wrap_AcquisitionControl_exposureTimeSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which exposure time is controlled by the ExposureTime feature.\n"
		"Selects which exposure time is controlled by the ExposureTime feature. This allows for independent control over the exposure components.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Blue** (Display string: 'Blue'): Selects the blue ExposureTime.\n"
		"- **Common** (Display string: 'Common'): Selects the common ExposureTime.\n"
		"- **Cyan** (Display string: 'Cyan'): Selects the cyan common ExposureTime.\n"
		"- **Green** (Display string: 'Green'): Selects the green ExposureTime.\n"
		"- **Infrared** (Display string: 'Infrared'): Selects the infrared ExposureTime.\n"
		"- **Magenta** (Display string: 'Magenta'): Selects the magenta ExposureTime.\n"
		"- **Red** (Display string: 'Red'): Selects the red common ExposureTime.\n"
		"- **Stage1** (Display string: 'Stage 1'): Selects the first stage ExposureTime.\n"
		"- **Stage2** (Display string: 'Stage 2'): Selects the second stage ExposureTime.\n"
		"- **Ultraviolet** (Display string: 'Ultraviolet'): Selects the ultraviolet ExposureTime.\n"
		"- **Yellow** (Display string: 'Yellow'): Selects the yellow ExposureTime.\n"
		"- **mvHorizontalZone0** (Display string: 'mv Horizontal Zone 0'): Selects the first horizontal exposure zone used when 'ExposureMode' is set to 'mvMultiZone' and when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.\n"
		"- **mvHorizontalZone1** (Display string: 'mv Horizontal Zone 1'): Selects the second horizontal exposure zone used when 'ExposureMode' is set to 'mvMultiZone' and when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_exposureTime_get", _wrap_AcquisitionControl_exposureTime_get, METH_O, "\n"
		"A floating point property. Sets the Exposure time when ExposureMode is Timed and ExposureAuto is Off.\n"
		"Sets the Exposure time when ExposureMode is Timed and ExposureAuto is Off. This controls the duration where the photosensitive cells are exposed to light.\n"
		""},
	 { "AcquisitionControl_mvExposureHorizontalZoneDivider_get", _wrap_AcquisitionControl_mvExposureHorizontalZoneDivider_get, METH_O, "\n"
		"A floating point property. Defines the position(in percent of the total number of lines) within the image to switch from one exposure time to the next.\n"
		"Defines the position(in percent of the total number of lines) within the image to switch from one exposure time to the next. 100% means that only one zone exists. 25% means that the upper 25% of the image are defined by the exposure time of 'mvHorizontalZone0' and the lower 75% are defined by the exposure time of 'mvHorizontalZone1'.\n"
		""},
	 { "AcquisitionControl_exposureAuto_get", _wrap_AcquisitionControl_exposureAuto_get, METH_O, "\n"
		"An enumerated integer property. Sets the automatic exposure mode when ExposureMode is Timed.\n"
		"Sets the automatic exposure mode when ExposureMode is Timed. The exact algorithm used to implement this control is device-specific.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Exposure duration is user controlled using ExposureTime.\n"
		"- **Once** (Display string: 'Once'): Exposure duration is adapted once by the device. Once it has converged, it returns to the Off state.\n"
		"- **Continuous** (Display string: 'Continuous'): Exposure duration is constantly adapted by the device to maximize the dynamic range.\n"
		"- **mvSequenced** (Display string: 'mv Sequenced')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_multiSlopeMode_get", _wrap_AcquisitionControl_multiSlopeMode_get, METH_O, "\n"
		"An enumerated integer property. Controls multi-slope exposure state.\n"
		"Controls multi-slope exposure state.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Off\n"
		"- **Manual** (Display string: 'Manual'): Manual\n"
		"- **PresetSoft** (Display string: 'Preset Soft'): Preset Soft\n"
		"- **PresetMedium** (Display string: 'Preset Medium'): Preset Medium\n"
		"- **PresetAggressive** (Display string: 'Preset Aggressive'): Preset Aggressive\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_multiSlopeKneePointCount_get", _wrap_AcquisitionControl_multiSlopeKneePointCount_get, METH_O, "\n"
		"An integer property. The number of knee-points as well as the number of additional exposure slopes used for multi-slope exposure.\n"
		"The number of knee-points as well as the number of additional exposure slopes used for multi-slope exposure.\n"
		""},
	 { "AcquisitionControl_multiSlopeKneePointSelector_get", _wrap_AcquisitionControl_multiSlopeKneePointSelector_get, METH_O, "\n"
		"An integer property. Selects the parameters for controlling an additional slope in multi-slope exposure.\n"
		"Selects the parameters for controlling an additional slope in multi-slope exposure.\n"
		""},
	 { "AcquisitionControl_multiSlopeExposureLimit_get", _wrap_AcquisitionControl_multiSlopeExposureLimit_get, METH_O, "\n"
		"A floating point property. Percent of the ExposureTime at a certain knee-point of multi-slope exposure.\n"
		"Percent of the ExposureTime at a certain knee-point of multi-slope exposure.\n"
		""},
	 { "AcquisitionControl_multiSlopeSaturationThreshold_get", _wrap_AcquisitionControl_multiSlopeSaturationThreshold_get, METH_O, "\n"
		"A floating point property. The percentage of the full saturation that is applied at a certain knee-point of a multi-slope exposure.\n"
		"The percentage of the full saturation that is applied at a certain knee-point of a multi-slope exposure.\n"
		""},
	 { "AcquisitionControl_multiSlopeIntensityLimit_get", _wrap_AcquisitionControl_multiSlopeIntensityLimit_get, METH_O, "\n"
		"A floating point property. The relative intensity which divides intensities influenced by different exposure slopes.\n"
		"The relative intensity which divides intensities influenced by different exposure slopes.\n"
		""},
	 { "AcquisitionControl_multiSlopeExposureGradient_get", _wrap_AcquisitionControl_multiSlopeExposureGradient_get, METH_O, "\n"
		"A floating point property. The gradient of the additional slope that is defined by this knee-point.\n"
		"The gradient of the additional slope that is defined by this knee-point.\n"
		""},
	 { "AcquisitionControl_exposureTimeAutoMax_get", _wrap_AcquisitionControl_exposureTimeAutoMax_get, METH_O, "\n"
		"A floating point property. Sets the max exposure time in auto mode.\n"
		"This value sets the max exposure time in us when ExposureAuto is Continuous.\n"
		""},
	 { "AcquisitionControl_exposureRegionOffsetX_get", _wrap_AcquisitionControl_exposureRegionOffsetX_get, METH_O, "\n"
		"An integer property. Offset X defining a rectangular region in the left rectified image for limiting the area used by auto exposure (in pixels).\n"
		"Offset X defining a rectangular region in the left rectified image for limiting the area used by auto exposure (in pixels).\n"
		""},
	 { "AcquisitionControl_exposureRegionOffsetY_get", _wrap_AcquisitionControl_exposureRegionOffsetY_get, METH_O, "\n"
		"An integer property. Offset Y defining a rectangular region in the left rectified image for limiting the area used by auto exposure (in pixels).\n"
		"Offset Y defining a rectangular region in the left rectified image for limiting the area used by auto exposure (in pixels).\n"
		""},
	 { "AcquisitionControl_exposureRegionWidth_get", _wrap_AcquisitionControl_exposureRegionWidth_get, METH_O, "\n"
		"An integer property. Width defining a rectangular region in the left rectified image for limiting the area used by auto exposure (in pixels).\n"
		"Width defining a rectangular region in the left rectified image for limiting the area used by auto exposure (in pixels).\n"
		""},
	 { "AcquisitionControl_exposureRegionHeight_get", _wrap_AcquisitionControl_exposureRegionHeight_get, METH_O, "\n"
		"An integer property. Height defining a rectangular region in the left rectified image for limiting the area used by auto exposure (in pixels).\n"
		"Height defining a rectangular region in the left rectified image for limiting the area used by auto exposure (in pixels).\n"
		""},
	 { "AcquisitionControl_acquisitionAlternateFilter_get", _wrap_AcquisitionControl_acquisitionAlternateFilter_get, METH_O, "\n"
		"An enumerated integer property. Filter images if LineSource is ExposureAlternateActive.\n"
		"Skip sending of some images depending on GPIO output value. This filter is considered if LineSource of Out1 or Out2 is ExposureAlternateActive.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The filter is turned off, i.e. all images are sent irrespective of the LineSource of Out1 and Out2.\n"
		"- **OnlyHigh** (Display string: 'Only High'): Only send images if LineSource of Out1 or Out2 is ExposureAlternateActive and output currently high.\n"
		"- **OnlyLow** (Display string: 'Only Low'): Only send images if LineSource of Out1 or Out2 is ExposureAlternateActive and output currently low.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_acquisitionMultiPartMode_get", _wrap_AcquisitionControl_acquisitionMultiPartMode_get, METH_O, "\n"
		"An enumerated integer property. Control which components are sent in a MultiPart buffer.\n"
		"Immediately send one single component per frame/buffer when it becomes available.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **SingleComponent** (Display string: 'Single Component'): Immediately send one single component per frame/buffer when it becomes available.\n"
		"- **SynchronizedComponents** (Display string: 'Synchronized Components'): Only send a frame/buffer if all enabled components are available for that time.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_rcExposureAutoAverageMax_get", _wrap_AcquisitionControl_rcExposureAutoAverageMax_get, METH_O, "\n"
		"A floating point property. Sets the maximum mean intensity in auto mode.\n"
		"This value sets the maximum mean intensity in auto mode as fraction between 0 and 1.\n"
		""},
	 { "AcquisitionControl_rcExposureAutoAverageMin_get", _wrap_AcquisitionControl_rcExposureAutoAverageMin_get, METH_O, "\n"
		"A floating point property. Sets the minimum mean intensity in auto mode.\n"
		"This value sets the minimum mean intensity in auto mode as fraction between 0 and 1.\n"
		""},
	 { "AcquisitionControl_mvAcquisitionFrameRateLimitMode_get", _wrap_AcquisitionControl_mvAcquisitionFrameRateLimitMode_get, METH_O, "\n"
		"An enumerated integer property. Controls the calculation of the maximum frame rate.\n"
		"Controls the calculation of the maximum frame rate.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvDeviceLinkThroughput** (Display string: 'mv Device Link Throughput'): Uses the highest possible frame rate depending on bandwidth and sensor settings.\n"
		"- **mvDeviceMaxSensorThroughput** (Display string: 'mv Device Max Sensor Throughput'): Maximum frame rate the sensor can provide depending on AOI and pixel clock. Note: Images might be buffered in the cameras memory. This can result in delayed images.\n"
		"- **mvLegacy** (Display string: 'mv Legacy'): Compatibility mode, not recommended.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvAcquisitionFrameRateEnable_get", _wrap_AcquisitionControl_mvAcquisitionFrameRateEnable_get, METH_O, "\n"
		"An enumerated integer property. Enables the use of the 'AcquisitionFrameRate' feature.\n"
		"Enables the use of the 'AcquisitionFrameRate' feature.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The acquisition frame rate is set automatically to the limit, calculated according to 'mvAcquisitionFrameRateLimitMode' feature.\n"
		"- **On** (Display string: 'On'): The acquisition frame rate is set by the 'AcquisitionFrameRate' feature.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvResultingFrameRate_get", _wrap_AcquisitionControl_mvResultingFrameRate_get, METH_O, "\n"
		"A floating point property. Shows the resulting frame rate.\n"
		"Shows the resulting frame rate.\n"
		""},
	 { "AcquisitionControl_mvShutterMode_get", _wrap_AcquisitionControl_mvShutterMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the shutter mode of the sensor.\n"
		"Selects the shutter mode of the sensor.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvRollingShutter** (Display string: 'mv Rolling Shutter')\n"
		"- **mvGlobalReset** (Display string: 'mv Global Reset')\n"
		"- **mvGlobalShutter** (Display string: 'mv Global Shutter')\n"
		"- **mvGlobalShutterWithoutReset** (Display string: 'mv Global Shutter Without Reset')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvCompressionKneepoint_get", _wrap_AcquisitionControl_mvCompressionKneepoint_get, METH_O, "\n"
		"An integer property. Knee point of 10 to 8 bit compression.\n"
		"Knee point of 10 to 8 bit compression.\n"
		""},
	 { "AcquisitionControl_mvExposureAutoLowerLimit_get", _wrap_AcquisitionControl_mvExposureAutoLowerLimit_get, METH_O, "\n"
		"A floating point property. The lower limit of the exposure time in auto exposure mode.\n"
		"The lower limit of the exposure time in auto exposure mode.\n"
		""},
	 { "AcquisitionControl_mvExposureAutoUpperLimit_get", _wrap_AcquisitionControl_mvExposureAutoUpperLimit_get, METH_O, "\n"
		"A floating point property. The upper limit of the exposure time in auto exposure mode.\n"
		"The upper limit of the exposure time in auto exposure mode.\n"
		""},
	 { "AcquisitionControl_mvExposureAutoSpeed_get", _wrap_AcquisitionControl_mvExposureAutoSpeed_get, METH_O, "\n"
		"An enumerated integer property. Determines the increment or decrement size of exposure value from frame to frame.\n"
		"Determines the increment or decrement size of exposure value from frame to frame.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Slow** (Display string: 'Slow')\n"
		"- **Medium** (Display string: 'Medium')\n"
		"- **Fast** (Display string: 'Fast')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvExposureAutoDelayImages_get", _wrap_AcquisitionControl_mvExposureAutoDelayImages_get, METH_O, "\n"
		"An integer property. The number of frames that the AEC must skip before updating the exposure register.\n"
		"The number of frames that the AEC must skip before updating the exposure register.\n"
		""},
	 { "AcquisitionControl_mvExposureAutoAverageGrey_get", _wrap_AcquisitionControl_mvExposureAutoAverageGrey_get, METH_O, "\n"
		"An integer property. Common desired average grey value (in percent) used for Auto Gain Control(AGC) and Auto Exposure Control(AEC).\n"
		"Common desired average grey value (in percent) used for auto gain control(AGC) and auto exposure control (AEC).\n"
		""},
	 { "AcquisitionControl_mvExposureAutoHighlightAOI_get", _wrap_AcquisitionControl_mvExposureAutoHighlightAOI_get, METH_O, "\n"
		"An enumerated integer property. Highlight auto control AOI to check AOI settings. Switch off for normal operation.\n"
		"Highlight auto control AOI to check AOI settings. Switch off for normal operation.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **On** (Display string: 'On')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvExposureAutoAOIMode_get", _wrap_AcquisitionControl_mvExposureAutoAOIMode_get, METH_O, "\n"
		"An enumerated integer property. Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvFull** (Display string: 'mv Full')\n"
		"- **mvCenter** (Display string: 'mv Center')\n"
		"- **mvUser** (Display string: 'mv User')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvExposureAutoOffsetX_get", _wrap_AcquisitionControl_mvExposureAutoOffsetX_get, METH_O, "\n"
		"An integer property. Common AOI XOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI XOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AcquisitionControl_mvExposureAutoOffsetY_get", _wrap_AcquisitionControl_mvExposureAutoOffsetY_get, METH_O, "\n"
		"An integer property. Common AOI YOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI YOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AcquisitionControl_mvExposureAutoWidth_get", _wrap_AcquisitionControl_mvExposureAutoWidth_get, METH_O, "\n"
		"An integer property. Common AOI Width used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Width used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AcquisitionControl_mvExposureAutoHeight_get", _wrap_AcquisitionControl_mvExposureAutoHeight_get, METH_O, "\n"
		"An integer property. Common AOI Height used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Height used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AcquisitionControl_mvExposureAutoMode_get", _wrap_AcquisitionControl_mvExposureAutoMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the common auto mode for gain and exposure.\n"
		"Selects the common auto mode for gain and exposure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvSensor** (Display string: 'mv Sensor'): The sensor itself will do the auto control.\n"
		"- **mvDevice** (Display string: 'mv Device'): The device(firmware) will do the auto control.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvSmearReduction_get", _wrap_AcquisitionControl_mvSmearReduction_get, METH_O, "\n"
		"An enumerated integer property. Smear reduction in triggered and non-overlapped mode.\n"
		"Smear reduction in triggered and non-overlapped mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvStandard** (Display string: 'mv Standard'): Standard smear reduction.\n"
		"- **mvMedium** (Display string: 'mv Medium'): Medium smear reduction.\n"
		"- **mvHighest** (Display string: 'mv Highest'): Highest smear but more power consumption.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvExposureActiveShiftEnable_get", _wrap_AcquisitionControl_mvExposureActiveShiftEnable_get, METH_O, "\n"
		"A boolean property. Enables the property to set the value of the shift between sensor exposure and the signal ExposureActive at the camera output.\n"
		"Enables the property to set the value of the shift between sensor exposure and the signal ExposureActive at the camera output.\n"
		""},
	 { "AcquisitionControl_mvExposureActiveShift_get", _wrap_AcquisitionControl_mvExposureActiveShift_get, METH_O, "\n"
		"An integer property. Sets the delay between the ExposureActive signal at the output and the exposure start at the sensor in us. Negative values mean ExposureActive is set to high before the exposure. Positive values mean ExposureActive is set to high after the exposure.\n"
		"Sets the delay between the ExposureActive signal at the output and the exposure start at the sensor in us. Negative values mean ExposureActive is set to high before the exposure. Positive values mean ExposureActive is set to high after the exposure.\n"
		""},
	 { "AcquisitionControl_mvAcquisitionMemoryMode_get", _wrap_AcquisitionControl_mvAcquisitionMemoryMode_get, METH_O, "\n"
		"An enumerated integer property. mvRecord is used to store frames in memory. mvPlayback transfers stored frames. mvPretrigger stores frames in memory to be transferred after trigger.\n"
		"mvRecord is used to store frames in memory. mvPlayback transfers stored frames. mvPretrigger stores frames in memory to be transferred after trigger.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Default** (Display string: 'Default'): Default memory mode.\n"
		"- **mvRecord** (Display string: 'mv Record'): Stores frames in memory.\n"
		"- **mvPlayback** (Display string: 'mv Playback'): Transfers stored frames.\n"
		"- **mvPretrigger** (Display string: 'mv Pretrigger'): Stores frames in memory to be transferred after trigger.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvPretriggerFrameCount_get", _wrap_AcquisitionControl_mvPretriggerFrameCount_get, METH_O, "\n"
		"An integer property. Number of frames to acquire before the occurrence of an AcquisitionStart or AcquisitionActive trigger.\n"
		"Number of frames to acquire before the occurrence of an AcquisitionStart or AcquisitionActive trigger.\n"
		""},
	 { "AcquisitionControl_mvAcquisitionMemoryMaxFrameCount_get", _wrap_AcquisitionControl_mvAcquisitionMemoryMaxFrameCount_get, METH_O, "\n"
		"An integer property. Maximum number of frames that can be recorded in the current configuration(deprecated, use the maximum value of 'mvAcquisitionMemoryFrameCount' instead).\n"
		"Deprecated: \n"
		"Maximum number of frames that can be recorded in the current configuration(deprecated, use the maximum value of 'mvAcquisitionMemoryFrameCount' instead).\n"
		""},
	 { "AcquisitionControl_mvAcquisitionMemoryFrameCount_get", _wrap_AcquisitionControl_mvAcquisitionMemoryFrameCount_get, METH_O, "\n"
		"An integer property. The number of frames currently stored in the frame buffer.\n"
		"The number of frames currently stored in the frame buffer. If this value keeps increasing this can indicate a bandwidth/transmission problem.\n"
		""},
	 { "AcquisitionControl_mvAcquisitionMemoryAOIParameterChanged_get", _wrap_AcquisitionControl_mvAcquisitionMemoryAOIParameterChanged_get, METH_O, "\n"
		"An integer property. AOI and/or binning parameter changed after last Acquisition.\n"
		"AOI and/or binning parameter changed after last Acquisition.\n"
		""},
	 { "AcquisitionControl_mvFeatureMode_get", _wrap_AcquisitionControl_mvFeatureMode_get, METH_O, "\n"
		"An enumerated integer property. Enables feature mode.\n"
		"Enables feature mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): No smart feature mode is selected\n"
		"- **mvJPEGWithRaw** (Display string: 'mv JPEG With Raw'): When active a binned raw image is sent together with a full resolution JPEG.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AcquisitionControl_mvSmartFrameRecallEnable_get", _wrap_AcquisitionControl_mvSmartFrameRecallEnable_get, METH_O, "\n"
		"A boolean property. When active in addition to the processed image data also the unprocessed image is stored inside the devices RAM.\n"
		"When active in addition to the processed image data (e.g. after binning, decimation, de-Bayering, LUT etc. applied inside the device) also the unprocessed image is stored inside the devices RAM allowing to request the transmission of these images by an application as well. This will effectively reduce the number of images that can be stored inside the frame buffer.\n"
		""},
	 { "AcquisitionControl_mvSmartFrameRecallTimestampLookupAccuracy_get", _wrap_AcquisitionControl_mvSmartFrameRecallTimestampLookupAccuracy_get, METH_O, "\n"
		"An integer property. This value defines the strictness of the timestamp-check for the recalled image (given in us).\n"
		"This value defines the strictness of the timestamp-check for the recalled image (given in us).\n"
		""},
	 { "AcquisitionControl_mvSmartFrameRecallFrameSkipRatio_get", _wrap_AcquisitionControl_mvSmartFrameRecallFrameSkipRatio_get, METH_O, "\n"
		"An integer property. When set to a value different from zero, the smaller frames get thinned out. AOI requests can still be done for all frames.\n"
		"The number of processed images to drop, i.e. skip. This can be used to reduce the frame rate even further. AOIs for unsent images can still be requested - the timestamps for these dropped images must be interpolated.\n"
		""},
	 { "AcquisitionControl_mvLensCalibrationEnable_get", _wrap_AcquisitionControl_mvLensCalibrationEnable_get, METH_O, "\n"
		"A boolean property. Enables or disables lens calibration.\n"
		"When active lens calibration will be applied to the image. The calibration data must have been correctly calculated for the scene and loaded into device memory using, for example, the file interface with filename 'mvLensCalibrationBlocks' and 'mvLensCalibrationPixels'. This will effectively reduce the number of images that can be stored inside the frame buffer.\n"
		""},
	 { "delete_AcquisitionControl", _wrap_delete_AcquisitionControl, METH_O, NULL},
	 { "AcquisitionControl_swigregister", AcquisitionControl_swigregister, METH_O, NULL},
	 { "AcquisitionControl_swiginit", AcquisitionControl_swiginit, METH_VARARGS, NULL},
	 { "new_AnalogControl", _wrap_new_AnalogControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::AnalogControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "AnalogControl_mvTapBalancingMode_get", _wrap_AnalogControl_mvTapBalancingMode_get, METH_O, "\n"
		"An enumerated integer property. Where do the tap balancing calibration data come from?\n"
		"Where do the tap balancing calibration data come from?\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvFactory** (Display string: 'mv Factory')\n"
		"- **mvUser** (Display string: 'mv User')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_mvGainMode_get", _wrap_AnalogControl_mvGainMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the operation mode of Gain.\n"
		"Sets the operation mode of Gain\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Default** (Display string: 'Default'): Default operation mode. The whole image is configured as a single zone.\n"
		"- **mvMultiZone** (Display string: 'mv Multi Zone'): In this mode different gains can be applied to different zones of the image by writing them into the 'mvHorizontalZone' registers selectable via the 'GainSelector'. This mode will only have effect on the image when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_gainSelector_get", _wrap_AnalogControl_gainSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Gain is controlled by the various Gain features.\n"
		"Selects which Gain is controlled by the various Gain features.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): Gain will be applied to all channels or taps.\n"
		"- **AnalogAll** (Display string: 'Analog All'): Gain will be applied to all analog channels or taps.\n"
		"- **AnalogBlue** (Display string: 'Analog Blue'): Gain will be applied to the blue analog channel.\n"
		"- **AnalogGreen** (Display string: 'Analog Green'): Gain will be applied to the green analog channel.\n"
		"- **AnalogRed** (Display string: 'Analog Red'): Gain will be applied to the red analog channel.\n"
		"- **AnalogTap1** (Display string: 'Analog Tap 1'): Analog gain will be applied to Tap 1.\n"
		"- **AnalogTap2** (Display string: 'Analog Tap 2'): Analog gain will be applied to Tap 2.\n"
		"- **AnalogTap3** (Display string: 'Analog Tap 3'): Analog gain will be applied to Tap 3.\n"
		"- **AnalogTap4** (Display string: 'Analog Tap 4'): Analog gain will be applied to Tap 4.\n"
		"- **AnalogTap5** (Display string: 'Analog Tap 5'): Analog gain will be applied to Tap 5.\n"
		"- **AnalogTap6** (Display string: 'Analog Tap 6'): Analog gain will be applied to Tap 6.\n"
		"- **AnalogTap7** (Display string: 'Analog Tap 7'): Analog gain will be applied to Tap 7.\n"
		"- **AnalogTap8** (Display string: 'Analog Tap 8'): Analog gain will be applied to Tap 8.\n"
		"- **AnalogTap9** (Display string: 'Analog Tap 9'): Analog gain will be applied to Tap 9.\n"
		"- **AnalogTap10** (Display string: 'Analog Tap 10'): Analog gain will be applied to Tap 10.\n"
		"- **AnalogTap11** (Display string: 'Analog Tap 11'): Analog gain will be applied to Tap 11.\n"
		"- **AnalogTap12** (Display string: 'Analog Tap 12'): Analog gain will be applied to Tap 12.\n"
		"- **AnalogTap13** (Display string: 'Analog Tap 13'): Analog gain will be applied to Tap 13.\n"
		"- **AnalogTap14** (Display string: 'Analog Tap 14'): Analog gain will be applied to Tap 14.\n"
		"- **AnalogTap15** (Display string: 'Analog Tap 15'): Analog gain will be applied to Tap 15.\n"
		"- **AnalogU** (Display string: 'Analog U'): Gain will be applied to U analog channel.\n"
		"- **AnalogV** (Display string: 'Analog V'): Gain will be applied to V analog channel.\n"
		"- **AnalogY** (Display string: 'Analog Y'): Gain will be applied to Y analog channel.\n"
		"- **Blue** (Display string: 'Blue'): Gain will be applied to the blue channel.\n"
		"- **DigitalAll** (Display string: 'Digital All'): Gain will be applied to all digital channels or taps.\n"
		"- **DigitalBlue** (Display string: 'Digital Blue'): Gain will be applied to the blue digital channel.\n"
		"- **DigitalGreen** (Display string: 'Digital Green'): Gain will be applied to the green digital channel.\n"
		"- **DigitalRed** (Display string: 'Digital Red'): Gain will be applied to the red digital channel.\n"
		"- **DigitalTap1** (Display string: 'Digital Tap 1'): Digital gain will be applied to Tap 1.\n"
		"- **DigitalTap2** (Display string: 'Digital Tap 2'): Digital gain will be applied to Tap 2.\n"
		"- **DigitalTap3** (Display string: 'Digital Tap 3'): Digital gain will be applied to Tap 3.\n"
		"- **DigitalTap4** (Display string: 'Digital Tap 4'): Digital gain will be applied to Tap 4.\n"
		"- **DigitalTap5** (Display string: 'Digital Tap 5'): Digital gain will be applied to Tap 5.\n"
		"- **DigitalTap6** (Display string: 'Digital Tap 6'): Digital gain will be applied to Tap 6.\n"
		"- **DigitalTap7** (Display string: 'Digital Tap 7'): Digital gain will be applied to Tap 7.\n"
		"- **DigitalTap8** (Display string: 'Digital Tap 8'): Digital gain will be applied to Tap 8.\n"
		"- **DigitalTap9** (Display string: 'Digital Tap 9'): Digital gain will be applied to Tap 9.\n"
		"- **DigitalTap10** (Display string: 'Digital Tap 10'): Digital gain will be applied to Tap 10.\n"
		"- **DigitalTap11** (Display string: 'Digital Tap 11'): Digital gain will be applied to Tap 11.\n"
		"- **DigitalTap12** (Display string: 'Digital Tap 12'): Digital gain will be applied to Tap 12.\n"
		"- **DigitalTap13** (Display string: 'Digital Tap 13'): Digital gain will be applied to Tap 13.\n"
		"- **DigitalTap14** (Display string: 'Digital Tap 14'): Digital gain will be applied to Tap 14.\n"
		"- **DigitalTap15** (Display string: 'Digital Tap 15'): Digital gain will be applied to Tap 15.\n"
		"- **DigitalU** (Display string: 'Digital U'): Gain will be applied to U digital channel.\n"
		"- **DigitalV** (Display string: 'Digital V'): Gain will be applied to V digital channel.\n"
		"- **DigitalY** (Display string: 'Digital Y'): Gain will be applied to Y digital channel.\n"
		"- **Green** (Display string: 'Green'): Gain will be applied to the green channel.\n"
		"- **Red** (Display string: 'Red'): Gain will be applied to the red channel.\n"
		"- **Tap1** (Display string: 'Tap 1'): Gain will be applied to Tap 1.\n"
		"- **Tap2** (Display string: 'Tap 2'): Gain will be applied to Tap 2.\n"
		"- **Tap3** (Display string: 'Tap 3'): Gain will be applied to Tap 3.\n"
		"- **Tap4** (Display string: 'Tap 4'): Gain will be applied to Tap 4.\n"
		"- **Tap5** (Display string: 'Tap 5'): Gain will be applied to Tap 5.\n"
		"- **Tap6** (Display string: 'Tap 6'): Gain will be applied to Tap 6.\n"
		"- **Tap7** (Display string: 'Tap 7'): Gain will be applied to Tap 7.\n"
		"- **Tap8** (Display string: 'Tap 8'): Gain will be applied to Tap 8.\n"
		"- **Tap9** (Display string: 'Tap 9'): Gain will be applied to Tap 9.\n"
		"- **Tap10** (Display string: 'Tap 10'): Gain will be applied to Tap 10.\n"
		"- **Tap11** (Display string: 'Tap 11'): Gain will be applied to Tap 11.\n"
		"- **Tap12** (Display string: 'Tap 12'): Gain will be applied to Tap 12.\n"
		"- **Tap13** (Display string: 'Tap 13'): Gain will be applied to Tap 13.\n"
		"- **Tap14** (Display string: 'Tap 14'): Gain will be applied to Tap 14.\n"
		"- **Tap15** (Display string: 'Tap 15'): Gain will be applied to Tap 15.\n"
		"- **U** (Display string: 'U'): Gain will be applied to U channel.\n"
		"- **V** (Display string: 'V'): Gain will be applied to V channel.\n"
		"- **Y** (Display string: 'Y'): Gain will be applied to Y channel.\n"
		"- **mvAnalogSensorA** (Display string: 'mv Analog Sensor A')\n"
		"- **mvAnalogSensorB** (Display string: 'mv Analog Sensor B')\n"
		"- **mvHorizontalZone0** (Display string: 'mv Horizontal Zone 0'): Selects the first horizontal gain zone used when 'mvGainMode' is set to 'mvMultiZone' and when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.\n"
		"- **mvHorizontalZone1** (Display string: 'mv Horizontal Zone 1'): Selects the second horizontal gain zone used when 'mvGainMode' is set to 'mvMultiZone' and when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_gain_get", _wrap_AnalogControl_gain_get, METH_O, "\n"
		"A floating point property. Controls the selected gain as an absolute physical value.\n"
		"Controls the selected gain as an absolute physical value. This is an amplification factor applied to the video signal.\n"
		""},
	 { "AnalogControl_mvGainHorizontalZoneDivider_get", _wrap_AnalogControl_mvGainHorizontalZoneDivider_get, METH_O, "\n"
		"A floating point property. Defines the position(in percent of the total number of lines) within the image to switch from one gain value to the next.\n"
		"Defines the position(in percent of the total number of lines) within the image to switch from one gain value to the next. 100% means that only one zone exists. 25% means that the upper 25% of the image are defined by the gain value of 'mvHorizontalZone0' and the lower 75% are defined by the gain value of 'mvHorizontalZone1'. Some sensors may only allow to change the gain at certain positions e.g. the last line of a defined ROI. In this case the first possible switching point above the actual line will be used.\n"
		""},
	 { "AnalogControl_gainAuto_get", _wrap_AnalogControl_gainAuto_get, METH_O, "\n"
		"An enumerated integer property. Sets the automatic gain control (AGC) mode.\n"
		"Sets the automatic gain control (AGC) mode. The exact algorithm used to implement AGC is device-specific.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Gain is User controlled using Gain.\n"
		"- **Once** (Display string: 'Once'): Gain is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.\n"
		"- **Continuous** (Display string: 'Continuous'): Gain is constantly adjusted by the device.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_gainAutoBalance_get", _wrap_AnalogControl_gainAutoBalance_get, METH_O, "\n"
		"An enumerated integer property. Sets the mode for automatic gain balancing between the sensor color channels or taps.\n"
		"Sets the mode for automatic gain balancing between the sensor color channels or taps. The gain coefficients of each channel or tap are adjusted so they are matched.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Gain tap balancing is user controlled using Gain .\n"
		"- **Once** (Display string: 'Once'): Gain tap balancing is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.\n"
		"- **Continuous** (Display string: 'Continuous'): Gain tap balancing is constantly adjusted by the device.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_blackLevelSelector_get", _wrap_AnalogControl_blackLevelSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Black Level is controlled by the various Black Level features.\n"
		"Selects which Black Level is controlled by the various Black Level features.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): Black Level will be applied to all channels or taps.\n"
		"- **Blue** (Display string: 'Blue'): Black Level will be applied to the blue channel.\n"
		"- **Green** (Display string: 'Green'): Black Level will be applied to the green channel.\n"
		"- **Red** (Display string: 'Red'): Black Level will be applied to the red channel.\n"
		"- **Tap1** (Display string: 'Tap 1'): Black Level will be applied to Tap 1.\n"
		"- **Tap2** (Display string: 'Tap 2'): Black Level will be applied to Tap 2.\n"
		"- **Tap3** (Display string: 'Tap 3'): Black Level will be applied to Tap 3.\n"
		"- **Tap4** (Display string: 'Tap 4'): Black Level will be applied to Tap 4.\n"
		"- **Tap5** (Display string: 'Tap 5'): Black Level will be applied to Tap 5.\n"
		"- **Tap6** (Display string: 'Tap 6'): Black Level will be applied to Tap 6.\n"
		"- **Tap7** (Display string: 'Tap 7'): Black Level will be applied to Tap 7.\n"
		"- **Tap8** (Display string: 'Tap 8'): Black Level will be applied to Tap 8.\n"
		"- **Tap9** (Display string: 'Tap 9'): Black Level will be applied to Tap 9.\n"
		"- **Tap10** (Display string: 'Tap 10'): Black Level will be applied to Tap 10.\n"
		"- **Tap11** (Display string: 'Tap 11'): Black Level will be applied to Tap 11.\n"
		"- **Tap12** (Display string: 'Tap 12'): Black Level will be applied to Tap 12.\n"
		"- **Tap13** (Display string: 'Tap 13'): Black Level will be applied to Tap 13.\n"
		"- **Tap14** (Display string: 'Tap 14'): Black Level will be applied to Tap 14.\n"
		"- **Tap15** (Display string: 'Tap 15'): Black Level will be applied to Tap 15.\n"
		"- **U** (Display string: 'U'): Black Level will be applied to U channel.\n"
		"- **V** (Display string: 'V'): Black Level will be applied to V channel.\n"
		"- **Y** (Display string: 'Y'): Black Level will be applied to Y channel.\n"
		"- **mvAnalogSensorA** (Display string: 'mv Analog Sensor A')\n"
		"- **mvAnalogSensorB** (Display string: 'mv Analog Sensor B')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_blackLevel_get", _wrap_AnalogControl_blackLevel_get, METH_O, "\n"
		"A floating point property. Controls the analog black level as an absolute physical value.\n"
		"Controls the analog black level as an absolute physical value. This represents a DC offset applied to the video signal.\n"
		""},
	 { "AnalogControl_blackLevelAuto_get", _wrap_AnalogControl_blackLevelAuto_get, METH_O, "\n"
		"An enumerated integer property. Controls the mode for automatic black level adjustment.\n"
		"Controls the mode for automatic black level adjustment. The exact algorithm used to implement this adjustment is device-specific.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Analog black level is user controlled using BlackLevel.\n"
		"- **Once** (Display string: 'Once'): Analog black level is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.\n"
		"- **Continuous** (Display string: 'Continuous'): Analog black level is constantly adjusted by the device.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_blackLevelAutoBalance_get", _wrap_AnalogControl_blackLevelAutoBalance_get, METH_O, "\n"
		"An enumerated integer property. Controls the mode for automatic black level balancing between the sensor color channels or taps.\n"
		"Controls the mode for automatic black level balancing between the sensor color channels or taps. The black level coefficients of each channel are adjusted so they are matched.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Black level tap balancing is user controlled using BlackLevel.\n"
		"- **Once** (Display string: 'Once'): Black level tap balancing is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.\n"
		"- **Continuous** (Display string: 'Continuous'): Black level tap balancing is constantly adjusted by the device.\n"
		"- **mvRaw** (Display string: 'mv Raw')\n"
		"- **mvFixed** (Display string: 'mv Fixed')\n"
		"- **mvLowerLine** (Display string: 'mv Lower Line')\n"
		"- **mvSlow** (Display string: 'mv Slow')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_whiteClipSelector_get", _wrap_AnalogControl_whiteClipSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which White Clip to control.\n"
		"Selects which White Clip to control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): White Clip will be applied to all channels or taps.\n"
		"- **Blue** (Display string: 'Blue'): White Clip will be applied to the blue channel.\n"
		"- **Green** (Display string: 'Green'): White Clip will be applied to the green channel.\n"
		"- **Red** (Display string: 'Red'): White Clip will be applied to the red channel.\n"
		"- **Tap1** (Display string: 'Tap 1'): White Clip will be applied to Tap 1.\n"
		"- **Tap2** (Display string: 'Tap 2'): White Clip will be applied to Tap 2.\n"
		"- **Tap3** (Display string: 'Tap 3'): White Clip will be applied to Tap 3.\n"
		"- **Tap4** (Display string: 'Tap 4'): White Clip will be applied to Tap 4.\n"
		"- **Tap5** (Display string: 'Tap 5'): White Clip will be applied to Tap 5.\n"
		"- **Tap6** (Display string: 'Tap 6'): White Clip will be applied to Tap 6.\n"
		"- **Tap7** (Display string: 'Tap 7'): White Clip will be applied to Tap 7.\n"
		"- **Tap8** (Display string: 'Tap 8'): White Clip will be applied to Tap 8.\n"
		"- **Tap9** (Display string: 'Tap 9'): White Clip will be applied to Tap 9.\n"
		"- **Tap10** (Display string: 'Tap 10'): White Clip will be applied to Tap 10.\n"
		"- **Tap11** (Display string: 'Tap 11'): White Clip will be applied to Tap 11.\n"
		"- **Tap12** (Display string: 'Tap 12'): White Clip will be applied to Tap 12.\n"
		"- **Tap13** (Display string: 'Tap 13'): White Clip will be applied to Tap 13.\n"
		"- **Tap14** (Display string: 'Tap 14'): White Clip will be applied to Tap 14.\n"
		"- **Tap15** (Display string: 'Tap 15'): White Clip will be applied to Tap 15.\n"
		"- **U** (Display string: 'U'): White Clip will be applied to U channel.\n"
		"- **V** (Display string: 'V'): White Clip will be applied to V channel.\n"
		"- **Y** (Display string: 'Y'): White Clip will be applied to Y channel.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_whiteClip_get", _wrap_AnalogControl_whiteClip_get, METH_O, "\n"
		"A floating point property. Controls the maximal intensity taken by the video signal before being clipped as an absolute physical value.\n"
		"Controls the maximal intensity taken by the video signal before being clipped as an absolute physical value. The video signal will never exceed the white clipping point: it will saturate at that level.\n"
		""},
	 { "AnalogControl_balanceRatioSelector_get", _wrap_AnalogControl_balanceRatioSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Balance ratio to control.\n"
		"Selects which Balance ratio to control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): Balance Ratio will be applied to all channels or taps.\n"
		"- **Blue** (Display string: 'Blue'): Balance Ratio will be applied to the blue channel.\n"
		"- **Green** (Display string: 'Green'): Balance Ratio will be applied to the green channel.\n"
		"- **Green0** (Display string: 'Green 0')\n"
		"- **Green1** (Display string: 'Green 1')\n"
		"- **Red** (Display string: 'Red'): Balance Ratio will be applied to the red channel.\n"
		"- **Tap1** (Display string: 'Tap 1'): Balance Ratio will be applied to Tap 1.\n"
		"- **Tap2** (Display string: 'Tap 2'): Balance Ratio will be applied to Tap 2.\n"
		"- **Tap3** (Display string: 'Tap 3'): Balance Ratio will be applied to Tap 3.\n"
		"- **Tap4** (Display string: 'Tap 4'): Balance Ratio will be applied to Tap 4.\n"
		"- **Tap5** (Display string: 'Tap 5'): Balance Ratio will be applied to Tap 5.\n"
		"- **Tap6** (Display string: 'Tap 6'): Balance Ratio will be applied to Tap 6.\n"
		"- **Tap7** (Display string: 'Tap 7'): Balance Ratio will be applied to Tap 7.\n"
		"- **Tap8** (Display string: 'Tap 8'): Balance Ratio will be applied to Tap 8.\n"
		"- **Tap9** (Display string: 'Tap 9'): Balance Ratio will be applied to Tap 9.\n"
		"- **Tap10** (Display string: 'Tap 10'): Balance Ratio will be applied to Tap 10.\n"
		"- **Tap11** (Display string: 'Tap 11'): Balance Ratio will be applied to Tap 11.\n"
		"- **Tap12** (Display string: 'Tap 12'): Balance Ratio will be applied to Tap 12.\n"
		"- **Tap13** (Display string: 'Tap 13'): Balance Ratio will be applied to Tap 13.\n"
		"- **Tap14** (Display string: 'Tap 14'): Balance Ratio will be applied to Tap 14.\n"
		"- **Tap15** (Display string: 'Tap 15'): Balance Ratio will be applied to Tap 15.\n"
		"- **U** (Display string: 'U'): Balance Ratio will be applied to U channel.\n"
		"- **V** (Display string: 'V'): Balance Ratio will be applied to V channel.\n"
		"- **Y** (Display string: 'Y'): Balance Ratio will be applied to Y channel.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_balanceRatio_get", _wrap_AnalogControl_balanceRatio_get, METH_O, "\n"
		"A floating point property. Controls ratio of the selected color component to a reference color component.\n"
		"Controls ratio of the selected color component to a reference color component. It is used for white balancing.\n"
		""},
	 { "AnalogControl_balanceWhiteAuto_get", _wrap_AnalogControl_balanceWhiteAuto_get, METH_O, "\n"
		"An enumerated integer property. Controls the mode for automatic white balancing between the color channels.\n"
		"Controls the mode for automatic white balancing between the color channels. The white balancing ratios are automatically adjusted.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): White balancing is user controlled using BalanceRatioSelector and BalanceRatio.\n"
		"- **Once** (Display string: 'Once'): White balancing is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.\n"
		"- **Continuous** (Display string: 'Continuous'): White balancing is constantly adjusted by the device.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_mvGainAutoDelayImages_get", _wrap_AnalogControl_mvGainAutoDelayImages_get, METH_O, "\n"
		"An integer property. The number of frames that the AEC must skip before updating the exposure register\n"
		"The number of frames that the AEC must skip before updating the exposure register\n"
		""},
	 { "AnalogControl_mvGainAutoUpperLimit_get", _wrap_AnalogControl_mvGainAutoUpperLimit_get, METH_O, "\n"
		"A floating point property. The upper limit of the gain in auto gain mode\n"
		"The upper limit of the gain in auto gain mode\n"
		""},
	 { "AnalogControl_mvGainAutoLowerLimit_get", _wrap_AnalogControl_mvGainAutoLowerLimit_get, METH_O, "\n"
		"A floating point property. The lower limit of the gain in auto gain mode\n"
		"The lower limit of the gain in auto gain mode\n"
		""},
	 { "AnalogControl_mvGainAutoSpeed_get", _wrap_AnalogControl_mvGainAutoSpeed_get, METH_O, "\n"
		"An enumerated integer property. Determines the increment or decrement size of gain value from frame to frame.\n"
		"Determines the increment or decrement size of gain value from frame to frame.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Slow** (Display string: 'Slow')\n"
		"- **Medium** (Display string: 'Medium')\n"
		"- **Fast** (Display string: 'Fast')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_mvGainAutoAverageGrey_get", _wrap_AnalogControl_mvGainAutoAverageGrey_get, METH_O, "\n"
		"An integer property. Common desired average grey value (in percent) used for Auto Gain Control(AGC) and Auto Exposure Control(AEC).\n"
		"Common desired average grey value (in percent) used for Auto Gain Control(AGC) and Auto Exposure Control(AEC).\n"
		""},
	 { "AnalogControl_mvGainAutoHighlightAOI_get", _wrap_AnalogControl_mvGainAutoHighlightAOI_get, METH_O, "\n"
		"An enumerated integer property. Highlight auto control AOI to check AOI settings. Switch off for normal operation.\n"
		"Highlight auto control AOI to check AOI settings. Switch off for normal operation.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **On** (Display string: 'On')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_mvGainAutoAOIMode_get", _wrap_AnalogControl_mvGainAutoAOIMode_get, METH_O, "\n"
		"An enumerated integer property. Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balancing.\n"
		"Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balancing.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvFull** (Display string: 'mv Full')\n"
		"- **mvCenter** (Display string: 'mv Center')\n"
		"- **mvUser** (Display string: 'mv User')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_mvGainAutoOffsetX_get", _wrap_AnalogControl_mvGainAutoOffsetX_get, METH_O, "\n"
		"An integer property. Common AOI X-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI X-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AnalogControl_mvGainAutoOffsetY_get", _wrap_AnalogControl_mvGainAutoOffsetY_get, METH_O, "\n"
		"An integer property. Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AnalogControl_mvGainAutoWidth_get", _wrap_AnalogControl_mvGainAutoWidth_get, METH_O, "\n"
		"An integer property. Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AnalogControl_mvGainAutoHeight_get", _wrap_AnalogControl_mvGainAutoHeight_get, METH_O, "\n"
		"An integer property. Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AnalogControl_mvGainAutoMode_get", _wrap_AnalogControl_mvGainAutoMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the common auto mode for gain and exposure.\n"
		"Selects the common auto mode for gain and exposure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvSensor** (Display string: 'mv Sensor'): The sensor itself will do the auto control.\n"
		"- **mvDevice** (Display string: 'mv Device'): The device(firmware) will do the auto control.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_mvBalanceWhiteAutoAOIMode_get", _wrap_AnalogControl_mvBalanceWhiteAutoAOIMode_get, METH_O, "\n"
		"An enumerated integer property. Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvFull** (Display string: 'mv Full')\n"
		"- **mvCenter** (Display string: 'mv Center')\n"
		"- **mvUser** (Display string: 'mv User')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_mvBalanceWhiteAutoOffsetX_get", _wrap_AnalogControl_mvBalanceWhiteAutoOffsetX_get, METH_O, "\n"
		"An integer property. Common AOI X-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI XOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AnalogControl_mvBalanceWhiteAutoOffsetY_get", _wrap_AnalogControl_mvBalanceWhiteAutoOffsetY_get, METH_O, "\n"
		"An integer property. Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AnalogControl_mvBalanceWhiteAutoWidth_get", _wrap_AnalogControl_mvBalanceWhiteAutoWidth_get, METH_O, "\n"
		"An integer property. Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AnalogControl_mvBalanceWhiteAutoHeight_get", _wrap_AnalogControl_mvBalanceWhiteAutoHeight_get, METH_O, "\n"
		"An integer property. Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "AnalogControl_mvLowLight_get", _wrap_AnalogControl_mvLowLight_get, METH_O, "\n"
		"An enumerated integer property. Makes the image brighter.\n"
		"Makes the image brighter.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **On** (Display string: 'On')\n"
		"- **Off** (Display string: 'Off')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_mvADCGain_get", _wrap_AnalogControl_mvADCGain_get, METH_O, "\n"
		"An integer property. Adapt gain. Gain value of the sensor may differ from sensor to sensor.\n"
		"Adapt gain. Gain value of the sensor may differ from sensor to sensor.\n"
		""},
	 { "AnalogControl_mvVRamp_get", _wrap_AnalogControl_mvVRamp_get, METH_O, "\n"
		"An integer property. Adjusting this value will result in better column CDS (correlated double sampling) which will remove the column FPN from the image.\n"
		"Adjusting this value will result in better column CDS (correlated double sampling) which will remove the column FPN from the image.\n"
		""},
	 { "AnalogControl_mvLinearLogarithmicMode_get", _wrap_AnalogControl_mvLinearLogarithmicMode_get, METH_O, "\n"
		"An integer property. Controls the knee point between linear response and logarithmic response.\n"
		"Controls the knee point between linear response and logarithmic response.\n"
		""},
	 { "AnalogControl_mvDigitalGainOffset_get", _wrap_AnalogControl_mvDigitalGainOffset_get, METH_O, "\n"
		"An integer property. Used for fine tuning of the brightness of the sensor.\n"
		"Used for fine tuning of the brightness of the sensor.\n"
		""},
	 { "AnalogControl_mvSaveCalibrationData_get", _wrap_AnalogControl_mvSaveCalibrationData_get, METH_O, "\n"
		"A method object. Saves the calibration data to non-volatile memory.\n"
		"Saves the calibration data to non-volatile memory.\n"
		""},
	 { "AnalogControl_mvGammaEnable_get", _wrap_AnalogControl_mvGammaEnable_get, METH_O, "\n"
		"A boolean property. Enables Gamma correction. All other LUT will be disabled.\n"
		"Enables gamma correction. All other LUT will be disabled.\n"
		""},
	 { "AnalogControl_mvGammaSelector_get", _wrap_AnalogControl_mvGammaSelector_get, METH_O, "\n"
		"An enumerated integer property. Sets the type of Gamma to be used.\n"
		"Sets the type of Gamma to be used.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvSRGB** (Display string: 'mv SRGB'): Gamma curve is fixed to a sRGB curve.\n"
		"- **mvUser** (Display string: 'mv User'): Gamma curve can be configured by user.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "AnalogControl_gamma_get", _wrap_AnalogControl_gamma_get, METH_O, "\n"
		"A floating point property. Controls the gamma correction of pixel intensity.\n"
		"Controls the gamma correction of pixel intensity.\n"
		"Since the human eye perceives light similar to a logarithm of real light intensity it's characteristic curve is\n"
		"non-linear. It follows the rule of (intensity ^ gamma) with a gamma value between 0.3-0.5.\n"
		"To provide as much useful information as possible, the image is converted from 12-bit acquired by the sensor to 8-bit utilizing\n"
		"this characteristic curve. The result is a linearized image optimized for the human eye's non-linear behavior which allows\n"
		"to perceive as much intensity differences as possible.\n"
		"Image: Gamma_correction_camera.png\n"
		"    Conversion from 12- to 8-bit utilizing the gamma function\n"
		""},
	 { "delete_AnalogControl", _wrap_delete_AnalogControl, METH_O, NULL},
	 { "AnalogControl_swigregister", AnalogControl_swigregister, METH_O, NULL},
	 { "AnalogControl_swiginit", AnalogControl_swiginit, METH_VARARGS, NULL},
	 { "new_LUTControl", _wrap_new_LUTControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::LUTControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "LUTControl_LUTSelector_get", _wrap_LUTControl_LUTSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which LUT to control.\n"
		"Selects which LUT to control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Luminance** (Display string: 'Luminance'): Selects the Luminance LUT.\n"
		"- **Red** (Display string: 'Red'): Selects the Red LUT.\n"
		"- **Green** (Display string: 'Green'): Selects the Green LUT.\n"
		"- **Blue** (Display string: 'Blue'): Selects the Blue LUT.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "LUTControl_LUTEnable_get", _wrap_LUTControl_LUTEnable_get, METH_O, "\n"
		"A boolean property. Activates the selected LUT.\n"
		"Activates the selected LUT.\n"
		""},
	 { "LUTControl_LUTIndex_get", _wrap_LUTControl_LUTIndex_get, METH_O, "\n"
		"An integer property. Control the index (offset) of the coefficient to access in the selected LUT.\n"
		"Control the index (offset) of the coefficient to access in the selected LUT.\n"
		""},
	 { "LUTControl_LUTValue_get", _wrap_LUTControl_LUTValue_get, METH_O, "\n"
		"An integer property. Returns the Value at entry LUTIndex of the LUT selected by LUTSelector.\n"
		"Returns the Value at entry LUTIndex of the LUT selected by LUTSelector.\n"
		""},
	 { "LUTControl_LUTValueAll_get", _wrap_LUTControl_LUTValueAll_get, METH_O, "\n"
		"A string property. Accesses all the LUT coefficients in a single access without using individual LUTIndex.\n"
		"Accesses all the LUT coefficients in a single access without using individual LUTIndex.\n"
		""},
	 { "LUTControl_mvLUTType_get", _wrap_LUTControl_mvLUTType_get, METH_O, "\n"
		"An enumerated integer property. Describes the type of LUT used.\n"
		"Describes the type of LUT used.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Direct** (Display string: 'Direct'): The user can define an output value for each input value of the LUT.\n"
		"- **Interpolated** (Display string: 'Interpolated'): The user can define the output values for equidistant nodes in the LUT. Linear interpolation is used to determine the output values for input values that lie in between the given nodes.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "LUTControl_mvLUTInputData_get", _wrap_LUTControl_mvLUTInputData_get, METH_O, "\n"
		"An enumerated integer property. Describes the data the LUT is operating on\n"
		"Describes the data the LUT is operating on\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Bayer** (Display string: 'Bayer'): The LUT is operating on raw Bayer data (i.e. before debayering)\n"
		"- **Gray** (Display string: 'Gray'): The LUT is operating on gray data\n"
		"- **RGB** (Display string: 'RGB'): The LUT is operating on RGB data (i.e. after debayering)\n"
		"- **DeviceSpecific** (Display string: 'Device Specific'): The LUT is operating on device specific data\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "LUTControl_mvLUTMapping_get", _wrap_LUTControl_mvLUTMapping_get, METH_O, "\n"
		"An enumerated integer property. Describes mapping of the LUT\n"
		"Describes the mapping of the LUT\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **map_8To12** (Display string: 'map 8 To 12'): The LUT maps 8 bit input data to 12 bit output data.\n"
		"- **map_10To12** (Display string: 'map 10 To 12'): The LUT maps 10 bit input data to 12 bit output data.\n"
		"- **map_10To10** (Display string: 'map 10 To 10'): The LUT maps 10 bit input data to 10 bit output data.\n"
		"- **map_8To10** (Display string: 'map 8 To 10'): The LUT maps 8 bit input data to 12 bit output data.\n"
		"- **map_12To10** (Display string: 'map 12 To 10'): The LUT maps 12 bit input data to 10 bit output data.\n"
		"- **map_10To9** (Display string: 'map 10 To 9'): The LUT maps 10 bit input data to 9 bit output data.\n"
		"- **map_12To9** (Display string: 'map 12 To 9'): The LUT maps 12 bit input data to 9 bit output data.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_LUTControl", _wrap_delete_LUTControl, METH_O, NULL},
	 { "LUTControl_swigregister", LUTControl_swigregister, METH_O, NULL},
	 { "LUTControl_swiginit", LUTControl_swiginit, METH_VARARGS, NULL},
	 { "new_ColorTransformationControl", _wrap_new_ColorTransformationControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::ColorTransformationControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "ColorTransformationControl_colorTransformationSelector_get", _wrap_ColorTransformationControl_colorTransformationSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Color Transformation module is controlled by the various Color Transformation features.\n"
		"Selects which Color Transformation module is controlled by the various Color Transformation features.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RGBtoRGB** (Display string: 'RGB to RGB'): RGB to RGB color transformation.\n"
		"- **RGBtoYUV** (Display string: 'RGB to YUV'): RGB to YUV color transformation.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ColorTransformationControl_colorTransformationEnable_get", _wrap_ColorTransformationControl_colorTransformationEnable_get, METH_O, "\n"
		"A boolean property. Activates the selected Color Transformation module.\n"
		"Activates the selected Color Transformation module.\n"
		""},
	 { "ColorTransformationControl_colorTransformationValueSelector_get", _wrap_ColorTransformationControl_colorTransformationValueSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the Gain factor or Offset of the Transformation matrix to access in the selected Color Transformation module.\n"
		"Selects the Gain factor or Offset of the Transformation matrix to access in the selected Color Transformation module.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Gain00** (Display string: 'Gain 00'): Gain 0,0 of the transformation matrix.\n"
		"- **Gain01** (Display string: 'Gain 01'): Gain 0,1 of the transformation matrix.\n"
		"- **Gain02** (Display string: 'Gain 02'): Gain 0,2 of the transformation matrix.\n"
		"- **Gain10** (Display string: 'Gain 10'): Gain 1,0 of the transformation matrix.\n"
		"- **Gain11** (Display string: 'Gain 11'): Gain 1,1 of the transformation matrix.\n"
		"- **Gain12** (Display string: 'Gain 12'): Gain 1,2 of the transformation matrix.\n"
		"- **Gain20** (Display string: 'Gain 20'): Gain 2,0 of the transformation matrix.\n"
		"- **Gain21** (Display string: 'Gain 21'): Gain 2,1 of the transformation matrix.\n"
		"- **Gain22** (Display string: 'Gain 22'): Gain 2,2 of the transformation matrix.\n"
		"- **Offset0** (Display string: 'Offset 0'): Offset 0 of the transformation matrix.\n"
		"- **Offset1** (Display string: 'Offset 1'): Offset 1 of the transformation matrix.\n"
		"- **Offset2** (Display string: 'Offset 2'): Offset 2 of the transformation matrix.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ColorTransformationControl_colorTransformationValue_get", _wrap_ColorTransformationControl_colorTransformationValue_get, METH_O, "\n"
		"A floating point property. Represents the value of the selected Gain factor or Offset inside the Transformation matrix.\n"
		"Represents the value of the selected Gain factor or Offset inside the Transformation matrix.\n"
		""},
	 { "delete_ColorTransformationControl", _wrap_delete_ColorTransformationControl, METH_O, NULL},
	 { "ColorTransformationControl_swigregister", ColorTransformationControl_swigregister, METH_O, NULL},
	 { "ColorTransformationControl_swiginit", ColorTransformationControl_swiginit, METH_VARARGS, NULL},
	 { "new_DigitalIOControl", _wrap_new_DigitalIOControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::DigitalIOControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "DigitalIOControl_lineSelector_get", _wrap_DigitalIOControl_lineSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the physical line (or pin) of the external device connector or the virtual line of the Transport Layer to configure.\n"
		"Selects the physical line (or pin) of the external device connector or the virtual line of the Transport Layer to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **CC1** (Display string: 'CC 1'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC2** (Display string: 'CC 2'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC3** (Display string: 'CC 3'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC4** (Display string: 'CC 4'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC5** (Display string: 'CC 5'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC6** (Display string: 'CC 6'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC7** (Display string: 'CC 7'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC8** (Display string: 'CC 8'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC9** (Display string: 'CC 9'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC10** (Display string: 'CC 10'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC11** (Display string: 'CC 11'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC12** (Display string: 'CC 12'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC13** (Display string: 'CC 13'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC14** (Display string: 'CC 14'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **CC15** (Display string: 'CC 15'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.\n"
		"- **Line0** (Display string: 'Line 0'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line1** (Display string: 'Line 1'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line2** (Display string: 'Line 2'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line3** (Display string: 'Line 3'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line4** (Display string: 'Line 4'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line5** (Display string: 'Line 5'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line6** (Display string: 'Line 6'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line7** (Display string: 'Line 7'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line8** (Display string: 'Line 8'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line9** (Display string: 'Line 9'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line10** (Display string: 'Line 10'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line11** (Display string: 'Line 11'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line12** (Display string: 'Line 12'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line13** (Display string: 'Line 13'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line14** (Display string: 'Line 14'): Index of the physical line and associated I/O control block to use.\n"
		"- **Line15** (Display string: 'Line 15'): Index of the physical line and associated I/O control block to use.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): Index of the virtual line going on the Transport layer to use.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): Index of the virtual line going on the Transport layer to use.\n"
		"- **LinkTrigger2** (Display string: 'Link Trigger 2'): Index of the virtual line going on the Transport layer to use.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		"\n"
		"See **lineStatusAll** to find out which line corresponds to which input or output of your device\n"
		""},
	 { "DigitalIOControl_lineMode_get", _wrap_DigitalIOControl_lineMode_get, METH_O, "\n"
		"An enumerated integer property. Controls if the physical Line is used to Input or Output a signal.\n"
		"Controls if the physical Line is used to Input or Output a signal.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Input** (Display string: 'Input'): The selected physical line is used to Input an electrical signal.\n"
		"- **Output** (Display string: 'Output'): The selected physical line is used to Output an electrical signal.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DigitalIOControl_lineInverter_get", _wrap_DigitalIOControl_lineInverter_get, METH_O, "\n"
		"A boolean property. Controls the inversion of the signal of the selected input or output Line.\n"
		"Controls the inversion of the signal of the selected input or output Line.\n"
		""},
	 { "DigitalIOControl_lineStatus_get", _wrap_DigitalIOControl_lineStatus_get, METH_O, "\n"
		"A boolean property. Returns the current status of the selected input or output Line.\n"
		"Returns the current status of the selected input or output Line.\n"
		""},
	 { "DigitalIOControl_lineStatusAll_get", _wrap_DigitalIOControl_lineStatusAll_get, METH_O, "\n"
		"An integer property. Returns the current status of all available Line signals at time of polling in a single bitfield.\n"
		"Returns the current status of all available Line signals at time of polling in a single bitfield.\n"
		"\n"
		"The following table documents which bit in this property represents the state of which digital I/O for **mvBlueCOUGAR-X** and **mvBlueFOX3** devices:\n"
		"\n"
		"\n"
		"|bit|IO|LineSelectorValue|\n"
		"|0|out 0|Line0|\n"
		"|1|out 1|Line1|\n"
		"|2|out 2|Line2|\n"
		"|3|out 3|Line3|\n"
		"|4|in 0|Line4|\n"
		"|5|in 1|Line5|\n"
		"\n"
		"\n"
		"The following table documents which bit in this property represents the state of which digital I/O for **mvBlueCOUGAR-X-POE** devices:\n"
		"\n"
		"\n"
		"|bit|IO|LineSelectorValue|\n"
		"|0|out 0|Line0|\n"
		"|1|out 1|Line1|\n"
		"|2|-|-|\n"
		"|3|-|-|\n"
		"|4|in 0|Line4|\n"
		"|5|in 1|Line5|\n"
		"\n"
		"\n"
		"The following table documents which bit in this property represents the state of which digital I/O for **mvBlueCOUGAR-X-POEI** **mvBlueCOUGAR-XD** devices:\n"
		"\n"
		"\n"
		"|bit|IO|LineSelectorValue|\n"
		"|0|out 0|Line0|\n"
		"|1|out 1|Line1|\n"
		"|2|out 2|Line2|\n"
		"|3|out 3|Line3|\n"
		"|4|in 0|Line4|\n"
		"|5|in 1|Line5|\n"
		"|6|in 2|Line6|\n"
		"|7|in 3|Line7|\n"
		""},
	 { "DigitalIOControl_lineSource_get", _wrap_DigitalIOControl_lineSource_get, METH_O, "\n"
		"An enumerated integer property. Selects which internal acquisition or I/O source signal to output on the selected Line.\n"
		"Selects which internal acquisition or I/O source signal to output on the selected Line. LineMode must be Output.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionActive** (Display string: 'Acquisition Active'): Device is currently doing an acquisition of one or many Frames.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device is currently waiting for a trigger for the capture of one or many Frames.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device has missed an Acquisition start trigger.\n"
		"- **AcquisitionTriggerWait** (Display string: 'Acquisition Trigger Wait'): Device is currently waiting for a trigger for the capture of one or many Frames.\n"
		"- **Counter0Active** (Display string: 'Counter 0 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter1Active** (Display string: 'Counter 1 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter2Active** (Display string: 'Counter 2 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter3Active** (Display string: 'Counter 3 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter4Active** (Display string: 'Counter 4 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter5Active** (Display string: 'Counter 5 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter6Active** (Display string: 'Counter 6 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter7Active** (Display string: 'Counter 7 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter8Active** (Display string: 'Counter 8 Active'): The chosen counter is in active state (counting).\n"
		"- **Encoder0** (Display string: 'Encoder 0'): The chosen Encoder Output state.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): The chosen Encoder Output state.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): The chosen Encoder Output state.\n"
		"- **ExposureActive** (Display string: 'Exposure Active'): Device is doing the exposure of a Frame (or Line).\n"
		"- **ExposureAlternateActive** (Display string: 'Exposure Alternate Active')\n"
		"- **FrameActive** (Display string: 'Frame Active'): Device is currently doing the capture of a Frame.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Device is currently waiting for a Frame start trigger.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device has missed a Frame start trigger.\n"
		"- **FrameTriggerWait** (Display string: 'Frame Trigger Wait'): Device is currently waiting for a Frame start trigger.\n"
		"- **High** (Display string: 'High')\n"
		"- **LineActive** (Display string: 'Line Active'): Device is currently doing the capture of a Line.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Device is currently waiting for a Line start trigger.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device has missed a Line start trigger.\n"
		"- **LineTriggerWait** (Display string: 'Line Trigger Wait'): Device is currently waiting for a Line start trigger.\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): The choosen Logic Block output state.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): The choosen Logic Block output state.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): The choosen Logic Block output state.\n"
		"- **Low** (Display string: 'Low')\n"
		"- **Off** (Display string: 'Off'): Line output is disabled (Tri-State).\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): The choosen Software Signal output state.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): The choosen Software Signal output state.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): The choosen Software Signal output state.\n"
		"- **Stream0TransferActive** (Display string: 'Stream 0 Transfer Active'): Transfer on the stream is active.\n"
		"- **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Transfer on the stream is in overflow.\n"
		"- **Stream0TransferPaused** (Display string: 'Stream 0 Transfer Paused'): Transfer on the stream is paused.\n"
		"- **Stream0TransferStopped** (Display string: 'Stream 0 Transfer Stopped'): Transfer on the stream is stopped.\n"
		"- **Stream0TransferStopping** (Display string: 'Stream 0 Transfer Stopping'): Transfer on the stream is stopping.\n"
		"- **Stream1TransferActive** (Display string: 'Stream 1 Transfer Active'): Transfer on the stream is active.\n"
		"- **Stream1TransferOverflow** (Display string: 'Stream 1 Transfer Overflow'): Transfer on the stream is in overflow.\n"
		"- **Stream1TransferPaused** (Display string: 'Stream 1 Transfer Paused'): Transfer on the stream is paused.\n"
		"- **Stream1TransferStopped** (Display string: 'Stream 1 Transfer Stopped'): Transfer on the stream is stopped.\n"
		"- **Stream1TransferStopping** (Display string: 'Stream 1 Transfer Stopping'): Transfer on the stream is stopping.\n"
		"- **Timer0Active** (Display string: 'Timer 0 Active'): The chosen Timer is in active state.\n"
		"- **Timer1Active** (Display string: 'Timer 1 Active'): The chosen Timer is in active state.\n"
		"- **Timer2Active** (Display string: 'Timer 2 Active'): The chosen Timer is in active state.\n"
		"- **UserOutput0** (Display string: 'User Output 0'): The chosen User Output Bit state as defined by its current UserOutputValue.\n"
		"- **UserOutput1** (Display string: 'User Output 1'): The chosen User Output Bit state as defined by its current UserOutputValue.\n"
		"- **UserOutput2** (Display string: 'User Output 2'): The chosen User Output Bit state as defined by its current UserOutputValue.\n"
		"- **UserOutput3** (Display string: 'User Output 3'): The chosen User Output Bit state as defined by its current UserOutputValue.\n"
		"- **UserOutput4** (Display string: 'User Output 4'): The chosen User Output Bit state as defined by its current UserOutputValue.\n"
		"- **UserOutput5** (Display string: 'User Output 5'): The chosen User Output Bit state as defined by its current UserOutputValue.\n"
		"- **UserOutput6** (Display string: 'User Output 6'): The chosen User Output Bit state as defined by its current UserOutputValue.\n"
		"- **UserOutput7** (Display string: 'User Output 7'): The chosen User Output Bit state as defined by its current UserOutputValue.\n"
		"- **mvExposureActive** (Display string: 'mv Exposure Active')\n"
		"- **mvExposureAndAcquisitionActive** (Display string: 'mv Exposure And Acquisition Active')\n"
		"- **mvExposureSensor2Active** (Display string: 'mv Exposure Sensor 2 Active')\n"
		"- **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')\n"
		"- **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')\n"
		"- **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')\n"
		"- **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')\n"
		"- **mvRTMOutput0** (Display string: 'mv RTM Output 0')\n"
		"- **mvRTMOutput1** (Display string: 'mv RTM Output 1')\n"
		"- **mvRTMOutput2** (Display string: 'mv RTM Output 2')\n"
		"- **mvRTMOutput3** (Display string: 'mv RTM Output 3')\n"
		"- **mvReadOutActive** (Display string: 'mv Read Out Active')\n"
		"- **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DigitalIOControl_lineFormat_get", _wrap_DigitalIOControl_lineFormat_get, METH_O, "\n"
		"An enumerated integer property. Controls the current electrical format of the selected physical input or output Line.\n"
		"Controls the current electrical format of the selected physical input or output Line.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NoConnect** (Display string: 'No Connect'): The Line is not connected.\n"
		"- **TriState** (Display string: 'Tri State'): The Line is currently in Tri-State mode (Not driven).\n"
		"- **TTL** (Display string: 'TTL'): The Line is currently accepting or sending TTL level signals.\n"
		"- **LVDS** (Display string: 'LVDS'): The Line is currently accepting or sending LVDS level signals.\n"
		"- **RS422** (Display string: 'RS 422'): The Line is currently accepting or sending RS422 level signals.\n"
		"- **OptoCoupled** (Display string: 'Opto Coupled'): The Line is opto-coupled.\n"
		"- **OpenDrain** (Display string: 'Open Drain'): The Line is Open Drain (or Open Collector).\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DigitalIOControl_userOutputSelector_get", _wrap_DigitalIOControl_userOutputSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which bit of the User Output register will be set by UserOutputValue.\n"
		"Selects which bit of the User Output register will be set by UserOutputValue.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **UserOutput0** (Display string: 'User Output 0'): Selects the bit 0 of the User Output register.\n"
		"- **UserOutput1** (Display string: 'User Output 1'): Selects the bit 1 of the User Output register.\n"
		"- **UserOutput2** (Display string: 'User Output 2'): Selects the bit 2 of the User Output register.\n"
		"- **UserOutput3** (Display string: 'User Output 3'): Selects the bit 3 of the User Output register.\n"
		"- **UserOutput4** (Display string: 'User Output 4'): Selects the bit 4 of the User Output register.\n"
		"- **UserOutput5** (Display string: 'User Output 5'): Selects the bit 5 of the User Output register.\n"
		"- **UserOutput6** (Display string: 'User Output 6'): Selects the bit 6 of the User Output register.\n"
		"- **UserOutput7** (Display string: 'User Output 7'): Selects the bit 7 of the User Output register.\n"
		"- **UserOutput8** (Display string: 'User Output 8'): Selects the bit 8 of the User Output register.\n"
		"- **UserOutput9** (Display string: 'User Output 9'): Selects the bit 9 of the User Output register.\n"
		"- **UserOutput10** (Display string: 'User Output 10'): Selects the bit 10 of the User Output register.\n"
		"- **UserOutput11** (Display string: 'User Output 11'): Selects the bit 11 of the User Output register.\n"
		"- **UserOutput12** (Display string: 'User Output 12'): Selects the bit 12 of the User Output register.\n"
		"- **UserOutput13** (Display string: 'User Output 13'): Selects the bit 13 of the User Output register.\n"
		"- **UserOutput14** (Display string: 'User Output 14'): Selects the bit 14 of the User Output register.\n"
		"- **UserOutput15** (Display string: 'User Output 15'): Selects the bit 15 of the User Output register.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DigitalIOControl_userOutputValue_get", _wrap_DigitalIOControl_userOutputValue_get, METH_O, "\n"
		"A boolean property. Sets the value of the bit selected by UserOutputSelector.\n"
		"Sets the value of the bit selected by UserOutputSelector.\n"
		""},
	 { "DigitalIOControl_userOutputValueAll_get", _wrap_DigitalIOControl_userOutputValueAll_get, METH_O, "\n"
		"An integer property. Sets the value of all the bits of the User Output register.\n"
		"Sets the value of all the bits of the User Output register. It is subject to the UserOutputValueAllMask.\n"
		""},
	 { "DigitalIOControl_userOutputValueAllMask_get", _wrap_DigitalIOControl_userOutputValueAllMask_get, METH_O, "\n"
		"An integer property. Sets the write mask to apply to the value specified by UserOutputValueAll before writing it in the User Output register.\n"
		"Sets the write mask to apply to the value specified by UserOutputValueAll before writing it in the User Output register. If the UserOutputValueAllMask feature is present, setting the user Output register using UserOutputValueAll will only change the bits that have a corresponding bit in the mask set to one.\n"
		""},
	 { "DigitalIOControl_mvLineDebounceTimeRisingEdge_get", _wrap_DigitalIOControl_mvLineDebounceTimeRisingEdge_get, METH_O, "\n"
		"An integer property. Sets the debounce time in micro seconds for low to high transitions.\n"
		"Sets the debounce time in micro seconds for low to high transitions.\n"
		""},
	 { "DigitalIOControl_mvLineDebounceTimeFallingEdge_get", _wrap_DigitalIOControl_mvLineDebounceTimeFallingEdge_get, METH_O, "\n"
		"An integer property. Sets the debounce time in micro seconds for high to low transitions.\n"
		"Sets the debounce time in micro seconds for high to low transitions.\n"
		""},
	 { "DigitalIOControl_mvRTMInputSelector_get", _wrap_DigitalIOControl_mvRTMInputSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which RTM input to configure.\n"
		"Selects which RTM input to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvRTMInput0** (Display string: 'mv RTM Input 0')\n"
		"- **mvRTMInput1** (Display string: 'mv RTM Input 1')\n"
		"- **mvRTMInput2** (Display string: 'mv RTM Input 2')\n"
		"- **mvRTMInput3** (Display string: 'mv RTM Input 3')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DigitalIOControl_mvRTMSource_get", _wrap_DigitalIOControl_mvRTMSource_get, METH_O, "\n"
		"An enumerated integer property. Selects which signal to connect to the selected RTM input.\n"
		"Selects which signal to connect to the selected RTM input.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **Line4** (Display string: 'Line 4')\n"
		"- **Line5** (Display string: 'Line 5')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DigitalIOControl_mvLineLED_get", _wrap_DigitalIOControl_mvLineLED_get, METH_O, "\n"
		"An enumerated integer property. Selects the digital I/O line to be stated by the LED\n"
		"Selects the digital I/O line to be stated by the LED\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **Line0** (Display string: 'Line 0')\n"
		"- **Line1** (Display string: 'Line 1')\n"
		"- **Line2** (Display string: 'Line 2')\n"
		"- **Line3** (Display string: 'Line 3')\n"
		"- **Line4** (Display string: 'Line 4')\n"
		"- **Line5** (Display string: 'Line 5')\n"
		"- **Line6** (Display string: 'Line 6')\n"
		"- **Line7** (Display string: 'Line 7')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DigitalIOControl_mvEnable12VPowerOut_get", _wrap_DigitalIOControl_mvEnable12VPowerOut_get, METH_O, "\n"
		"A boolean property. Enable 12V power out on MultipurposeIO POWER_OUT pin.\n"
		"Enable 12V power out on MultipurposeIO POWER_OUT pin.\n"
		""},
	 { "delete_DigitalIOControl", _wrap_delete_DigitalIOControl, METH_O, NULL},
	 { "DigitalIOControl_swigregister", DigitalIOControl_swigregister, METH_O, NULL},
	 { "DigitalIOControl_swiginit", DigitalIOControl_swiginit, METH_VARARGS, NULL},
	 { "new_CounterAndTimerControl", _wrap_new_CounterAndTimerControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::CounterAndTimerControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "CounterAndTimerControl_counterSelector_get", _wrap_CounterAndTimerControl_counterSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Counter to configure.\n"
		"Selects which Counter to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Counter0** (Display string: 'Counter 0'): Selects the counter 0.\n"
		"- **Counter1** (Display string: 'Counter 1'): Selects the counter 1.\n"
		"- **Counter2** (Display string: 'Counter 2'): Selects the counter 2.\n"
		"- **Counter3** (Display string: 'Counter 3'): Selects the counter 3.\n"
		"- **Counter4** (Display string: 'Counter 4'): Selects the counter 4.\n"
		"- **Counter5** (Display string: 'Counter 5'): Selects the counter 5.\n"
		"- **Counter6** (Display string: 'Counter 6'): Selects the counter 6.\n"
		"- **Counter7** (Display string: 'Counter 7'): Selects the counter 7.\n"
		"- **Counter8** (Display string: 'Counter 8'): Selects the counter 8.\n"
		"- **Counter9** (Display string: 'Counter 9'): Selects the counter 9.\n"
		"- **Counter10** (Display string: 'Counter 10'): Selects the counter 10.\n"
		"- **Counter11** (Display string: 'Counter 11'): Selects the counter 11.\n"
		"- **Counter12** (Display string: 'Counter 12'): Selects the counter 12.\n"
		"- **Counter13** (Display string: 'Counter 13'): Selects the counter 13.\n"
		"- **Counter14** (Display string: 'Counter 14'): Selects the counter 14.\n"
		"- **Counter15** (Display string: 'Counter 15'): Selects the counter 15.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_counterEventSource_get", _wrap_CounterAndTimerControl_counterEventSource_get, METH_O, "\n"
		"An enumerated integer property. Select the events that will be the source to increment the Counter.\n"
		"Select the events that will be the source to increment the Counter.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Counts the number of Acquisition End.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Counts the number of Acquisition Start.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Counts the number of Acquisition Trigger.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Counts the number of missed Acquisition Start Trigger.\n"
		"- **Action0** (Display string: 'Action 0'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action1** (Display string: 'Action 1'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action2** (Display string: 'Action 2'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action3** (Display string: 'Action 3'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action4** (Display string: 'Action 4'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action5** (Display string: 'Action 5'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action6** (Display string: 'Action 6'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action7** (Display string: 'Action 7'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action8** (Display string: 'Action 8'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action9** (Display string: 'Action 9'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action10** (Display string: 'Action 10'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action11** (Display string: 'Action 11'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action12** (Display string: 'Action 12'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action13** (Display string: 'Action 13'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action14** (Display string: 'Action 14'): Counts the number of assertions of the chosen action signal.\n"
		"- **Action15** (Display string: 'Action 15'): Counts the number of assertions of the chosen action signal.\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): Counts the number of Counter End.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): Counts the number of Counter Start.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): Counts the number of Counter End.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): Counts the number of Counter Start.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): Counts the number of Counter End.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): Counts the number of Counter Start.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): Counts the number of Counter End.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): Counts the number of Counter End.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): Counts the number of Counter End.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): Counts the number of Counter End.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): Counts the number of Counter End.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): Counts the number of Counter End.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): Counts the number of Counter End.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): Counts the number of Counter End.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): Counts the number of Counter End.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): Counts the number of Counter End.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): Counts the number of Counter End.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): Counts the number of Counter End.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): Counts the number of Counter End.\n"
		"- **Encoder0** (Display string: 'Encoder 0'): Counts the number of Encoder output pulses.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): Counts the number of Encoder output pulses.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): Counts the number of Encoder output pulses.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Counts the number of Exposure End.\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Counts the number of Exposure Start.\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Counts the number of Frame Burst End.\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Counts the number of Frame Burst Start.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Counts the number of Frame End.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Counts the number of Frame Start.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Counts the number of Frame Start Trigger.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Counts the number of missed Frame Start Trigger.\n"
		"- **Line0** (Display string: 'Line 0'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line0RisingEdge** (Display string: 'Line 0 Rising Edge')\n"
		"- **Line1** (Display string: 'Line 1'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line1RisingEdge** (Display string: 'Line 1 Rising Edge')\n"
		"- **Line2** (Display string: 'Line 2'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line2RisingEdge** (Display string: 'Line 2 Rising Edge')\n"
		"- **Line3** (Display string: 'Line 3'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line3RisingEdge** (Display string: 'Line 3 Rising Edge')\n"
		"- **Line4** (Display string: 'Line 4'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line4RisingEdge** (Display string: 'Line 4 Rising Edge')\n"
		"- **Line5** (Display string: 'Line 5'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line5RisingEdge** (Display string: 'Line 5 Rising Edge')\n"
		"- **Line6** (Display string: 'Line 6'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line6RisingEdge** (Display string: 'Line 6 Rising Edge')\n"
		"- **Line7** (Display string: 'Line 7'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line7RisingEdge** (Display string: 'Line 7 Rising Edge')\n"
		"- **Line8** (Display string: 'Line 8'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line8RisingEdge** (Display string: 'Line 8 Rising Edge')\n"
		"- **Line9** (Display string: 'Line 9'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line9RisingEdge** (Display string: 'Line 9 Rising Edge')\n"
		"- **Line10** (Display string: 'Line 10'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line10RisingEdge** (Display string: 'Line 10 Rising Edge')\n"
		"- **Line11** (Display string: 'Line 11'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line11RisingEdge** (Display string: 'Line 11 Rising Edge')\n"
		"- **Line12** (Display string: 'Line 12'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line12RisingEdge** (Display string: 'Line 12 Rising Edge')\n"
		"- **Line13** (Display string: 'Line 13'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line13RisingEdge** (Display string: 'Line 13 Rising Edge')\n"
		"- **Line14** (Display string: 'Line 14'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line14RisingEdge** (Display string: 'Line 14 Rising Edge')\n"
		"- **Line15** (Display string: 'Line 15'): Counts the number of transitions on the chosen I/O Line.\n"
		"- **Line15RisingEdge** (Display string: 'Line 15 Rising Edge')\n"
		"- **LineEnd** (Display string: 'Line End'): Counts the number of Line End.\n"
		"- **LineStart** (Display string: 'Line Start'): Counts the number of Line Start.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Counts the number of Line Start Trigger.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Counts the number of missed Line Start Trigger.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): Counts the number of  Link Triggers.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): Counts the number of  Link Triggers.\n"
		"- **LinkTrigger2** (Display string: 'Link Trigger 2'): Counts the number of  Link Triggers.\n"
		"- **LinkTriggerMissed0** (Display string: 'Link Trigger Missed 0'): Counts the number of Link Triggers missed.\n"
		"- **LinkTriggerMissed1** (Display string: 'Link Trigger Missed 1'): Counts the number of Link Triggers missed.\n"
		"- **LinkTriggerMissed2** (Display string: 'Link Trigger Missed 2'): Counts the number of Link Triggers missed.\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): Counts the number of Logic Block output pulses.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): Counts the number of Logic Block output pulses.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): Counts the number of Logic Block output pulses.\n"
		"- **Off** (Display string: 'Off'): Counter is stopped.\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): Counts the number of Software Signal.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): Counts the number of Software Signal.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): Counts the number of Software Signal.\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): Counts the number of Timer Start pulses generated.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): Counts the number of Timer Start pulses generated.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): Counts the number of Timer Start pulses generated.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): Counts the number of Timer End pulses generated.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): Counts the number of Timer End pulses generated.\n"
		"- **TimestampTick** (Display string: 'Timestamp Tick'): Counts the number of clock ticks of the Timestamp clock. Can be used to create a programmable timer.\n"
		"- **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')\n"
		"- **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')\n"
		"- **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')\n"
		"- **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')\n"
		"- **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_counterEventActivation_get", _wrap_CounterAndTimerControl_counterEventActivation_get, METH_O, "\n"
		"An enumerated integer property. Selects the Activation mode Event Source signal.\n"
		"Selects the Activation mode Event Source signal.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RisingEdge** (Display string: 'Rising Edge'): Counts on the Rising Edge of the signal.\n"
		"- **FallingEdge** (Display string: 'Falling Edge'): Counts on the Falling Edge of the signal.\n"
		"- **AnyEdge** (Display string: 'Any Edge'): Counts on the Falling or rising Edge of the selected signal.\n"
		"- **LevelHigh** (Display string: 'Level High')\n"
		"- **LevelLow** (Display string: 'Level Low')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_counterResetSource_get", _wrap_CounterAndTimerControl_counterResetSource_get, METH_O, "\n"
		"An enumerated integer property. Selects the signals that will be the source to reset the Counter.\n"
		"Selects the signals that will be the source to reset the Counter.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Resets with the reception of the Acquisition End.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Resets with the reception of the Acquisition Start.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Resets with the reception of the Acquisition Trigger.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Resets with the reception of the missed Acquisition start trigger.\n"
		"- **Action0** (Display string: 'Action 0'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action1** (Display string: 'Action 1'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action2** (Display string: 'Action 2'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action3** (Display string: 'Action 3'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action4** (Display string: 'Action 4'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action5** (Display string: 'Action 5'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action6** (Display string: 'Action 6'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action7** (Display string: 'Action 7'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action8** (Display string: 'Action 8'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action9** (Display string: 'Action 9'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action10** (Display string: 'Action 10'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action11** (Display string: 'Action 11'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action12** (Display string: 'Action 12'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action13** (Display string: 'Action 13'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action14** (Display string: 'Action 14'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action15** (Display string: 'Action 15'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): Resets with the reception of the Counter End.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): Resets with the reception of the Counter Start.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): Resets with the reception of the Counter End.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): Resets with the reception of the Counter Start.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): Resets with the reception of the Counter End.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): Resets with the reception of the Counter Start.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): Resets with the reception of the Counter End.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): Resets with the reception of the Counter End.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): Resets with the reception of the Counter End.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): Resets with the reception of the Counter End.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): Resets with the reception of the Counter End.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): Resets with the reception of the Counter End.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): Resets with the reception of the Counter End.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): Resets with the reception of the Counter End.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): Resets with the reception of the Counter End.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): Resets with the reception of the Counter End.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): Resets with the reception of the Counter End.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): Resets with the reception of the Counter End.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): Resets with the reception of the Counter End.\n"
		"- **CounterTrigger** (Display string: 'Counter Trigger'): Resets with the reception of a trigger on the CounterTriggerSource.\n"
		"- **Encoder0** (Display string: 'Encoder 0'): Resets with the reception of the Encoder output signal.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): Resets with the reception of the Encoder output signal.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): Resets with the reception of the Encoder output signal.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Resets with the reception of the Exposure End.\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Resets with the reception of the Exposure Start.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Resets with the reception of the Frame End.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Resets with the reception of the Frame Start.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Resets with the reception of the Frame Start Trigger.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Resets with the reception of the missed Frame start trigger.\n"
		"- **Line0** (Display string: 'Line 0'): Resets by the chosen I/O Line.\n"
		"- **Line1** (Display string: 'Line 1'): Resets by the chosen I/O Line.\n"
		"- **Line2** (Display string: 'Line 2'): Resets by the chosen I/O Line.\n"
		"- **Line3** (Display string: 'Line 3'): Resets by the chosen I/O Line.\n"
		"- **Line4** (Display string: 'Line 4'): Resets by the chosen I/O Line.\n"
		"- **Line5** (Display string: 'Line 5'): Resets by the chosen I/O Line.\n"
		"- **Line6** (Display string: 'Line 6'): Resets by the chosen I/O Line.\n"
		"- **Line7** (Display string: 'Line 7'): Resets by the chosen I/O Line.\n"
		"- **Line8** (Display string: 'Line 8'): Resets by the chosen I/O Line.\n"
		"- **Line9** (Display string: 'Line 9'): Resets by the chosen I/O Line.\n"
		"- **Line10** (Display string: 'Line 10'): Resets by the chosen I/O Line.\n"
		"- **Line11** (Display string: 'Line 11'): Resets by the chosen I/O Line.\n"
		"- **Line12** (Display string: 'Line 12'): Resets by the chosen I/O Line.\n"
		"- **Line13** (Display string: 'Line 13'): Resets by the chosen I/O Line.\n"
		"- **Line14** (Display string: 'Line 14'): Resets by the chosen I/O Line.\n"
		"- **Line15** (Display string: 'Line 15'): Resets by the chosen I/O Line.\n"
		"- **LineEnd** (Display string: 'Line End'): Resets with the reception of the Line End.\n"
		"- **LineStart** (Display string: 'Line Start'): Resets with the reception of the Line Start.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Resets with the reception of the Line Start Trigger.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Resets with the reception of the missed Line start trigger.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): Resets on the reception of the chosen Link Trigger (received from the transport layer).\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): Resets on the reception of the chosen Link Trigger (received from the transport layer).\n"
		"- **LinkTrigger2** (Display string: 'Link Trigger 2'): Resets on the reception of the chosen Link Trigger (received from the transport layer).\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): Resets with the reception of the LogicBlock output signal.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): Resets with the reception of the LogicBlock output signal.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): Resets with the reception of the LogicBlock output signal.\n"
		"- **Off** (Display string: 'Off'): Disable the Counter Reset trigger.\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): Resets on the reception of the Software Signal.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): Resets on the reception of the Software Signal.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): Resets on the reception of the Software Signal.\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): Resets with the reception of the Timer End.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): Resets with the reception of the Timer Start.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): Resets with the reception of the Timer End.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): Resets with the reception of the Timer Start.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): Resets with the reception of the Timer End.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): Resets with the reception of the Timer Start.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): Resets with the reception of the Timer End.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): Resets with the reception of the Timer End.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): Resets with the reception of the Timer End.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): Resets with the reception of the Timer End.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): Resets with the reception of the Timer End.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): Resets with the reception of the Timer End.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): Resets with the reception of the Timer End.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): Resets with the reception of the Timer End.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): Resets with the reception of the Timer End.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): Resets with the reception of the Timer End.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): Resets with the reception of the Timer End.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): Resets with the reception of the Timer End.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): Resets with the reception of the Timer End.\n"
		"- **UserOutput0** (Display string: 'User Output 0'): Resets by the chosen User Output bit.\n"
		"- **UserOutput1** (Display string: 'User Output 1'): Resets by the chosen User Output bit.\n"
		"- **UserOutput2** (Display string: 'User Output 2'): Resets by the chosen User Output bit.\n"
		"- **UserOutput3** (Display string: 'User Output 3'): Resets by the chosen User Output bit.\n"
		"- **UserOutput4** (Display string: 'User Output 4'): Resets by the chosen User Output bit.\n"
		"- **UserOutput5** (Display string: 'User Output 5'): Resets by the chosen User Output bit.\n"
		"- **UserOutput6** (Display string: 'User Output 6'): Resets by the chosen User Output bit.\n"
		"- **UserOutput7** (Display string: 'User Output 7'): Resets by the chosen User Output bit.\n"
		"- **UserOutput8** (Display string: 'User Output 8'): Resets by the chosen User Output bit.\n"
		"- **UserOutput9** (Display string: 'User Output 9'): Resets by the chosen User Output bit.\n"
		"- **UserOutput10** (Display string: 'User Output 10'): Resets by the chosen User Output bit.\n"
		"- **UserOutput11** (Display string: 'User Output 11'): Resets by the chosen User Output bit.\n"
		"- **UserOutput12** (Display string: 'User Output 12'): Resets by the chosen User Output bit.\n"
		"- **UserOutput13** (Display string: 'User Output 13'): Resets by the chosen User Output bit.\n"
		"- **UserOutput14** (Display string: 'User Output 14'): Resets by the chosen User Output bit.\n"
		"- **UserOutput15** (Display string: 'User Output 15'): Resets by the chosen User Output bit.\n"
		"- **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')\n"
		"- **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')\n"
		"- **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')\n"
		"- **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')\n"
		"- **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_counterResetActivation_get", _wrap_CounterAndTimerControl_counterResetActivation_get, METH_O, "\n"
		"An enumerated integer property. Selects the Activation mode of the Counter Reset Source signal.\n"
		"Selects the Activation mode of the Counter Reset Source signal.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RisingEdge** (Display string: 'Rising Edge'): Resets the counter on the Rising Edge of the signal.\n"
		"- **FallingEdge** (Display string: 'Falling Edge'): Resets the counter on the Falling Edge of the signal.\n"
		"- **AnyEdge** (Display string: 'Any Edge'): Resets the counter on the Falling or rising Edge of the selected signal.\n"
		"- **LevelHigh** (Display string: 'Level High'): Resets the counter as long as the selected signal level is High.\n"
		"- **LevelLow** (Display string: 'Level Low'): Resets the counter as long as the selected signal level is Low.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_counterReset_get", _wrap_CounterAndTimerControl_counterReset_get, METH_O, "\n"
		"A method object. Does a software reset of the selected Counter and starts it.\n"
		"Does a software reset of the selected Counter and starts it. The counter starts counting events immediately after the reset unless a Counter trigger is active. CounterReset can be used to reset the Counter independently from the CounterResetSource. To disable the counter temporarily, set CounterEventSource to Off.\n"
		""},
	 { "CounterAndTimerControl_counterValue_get", _wrap_CounterAndTimerControl_counterValue_get, METH_O, "\n"
		"An integer property. Reads or writes the current value of the selected Counter.\n"
		"Reads or writes the current value of the selected Counter.\n"
		""},
	 { "CounterAndTimerControl_counterValueAtReset_get", _wrap_CounterAndTimerControl_counterValueAtReset_get, METH_O, "\n"
		"An integer property. Reads the value of the selected Counter when it was reset by a trigger or by an explicit CounterReset command.\n"
		"Reads the value of the selected Counter when it was reset by a trigger or by an explicit CounterReset command.\n"
		""},
	 { "CounterAndTimerControl_counterDuration_get", _wrap_CounterAndTimerControl_counterDuration_get, METH_O, "\n"
		"An integer property. Sets the duration (or number of events) before the CounterEnd event is generated.\n"
		"Sets the duration (or number of events) before the CounterEnd event is generated.\n"
		""},
	 { "CounterAndTimerControl_counterStatus_get", _wrap_CounterAndTimerControl_counterStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the current status of the Counter.\n"
		"Returns the current status of the Counter.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **CounterIdle** (Display string: 'Counter Idle'): The counter is idle.\n"
		"- **CounterTriggerWait** (Display string: 'Counter Trigger Wait'): The counter is waiting for a start trigger.\n"
		"- **CounterActive** (Display string: 'Counter Active'): The counter is counting for the specified duration.\n"
		"- **CounterCompleted** (Display string: 'Counter Completed'): The counter reached the CounterDuration count.\n"
		"- **CounterOverflow** (Display string: 'Counter Overflow'): The counter reached its maximum possible count.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_counterTriggerSource_get", _wrap_CounterAndTimerControl_counterTriggerSource_get, METH_O, "\n"
		"An enumerated integer property. Selects the source to start the Counter.\n"
		"Selects the source to start the Counter.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Starts with the reception of the Acquisition End.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Starts with the reception of the Acquisition Start.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Starts with the reception of the Acquisition Trigger.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device has missed an Acquisition start trigger.\n"
		"- **Action0** (Display string: 'Action 0'): Starts with the assertion of the chosen action signal.\n"
		"- **Action1** (Display string: 'Action 1'): Starts with the assertion of the chosen action signal.\n"
		"- **Action2** (Display string: 'Action 2'): Starts with the assertion of the chosen action signal.\n"
		"- **Action3** (Display string: 'Action 3'): Starts with the assertion of the chosen action signal.\n"
		"- **Action4** (Display string: 'Action 4'): Starts with the assertion of the chosen action signal.\n"
		"- **Action5** (Display string: 'Action 5'): Starts with the assertion of the chosen action signal.\n"
		"- **Action6** (Display string: 'Action 6'): Starts with the assertion of the chosen action signal.\n"
		"- **Action7** (Display string: 'Action 7'): Starts with the assertion of the chosen action signal.\n"
		"- **Action8** (Display string: 'Action 8'): Starts with the assertion of the chosen action signal.\n"
		"- **Action9** (Display string: 'Action 9'): Starts with the assertion of the chosen action signal.\n"
		"- **Action10** (Display string: 'Action 10'): Starts with the assertion of the chosen action signal.\n"
		"- **Action11** (Display string: 'Action 11'): Starts with the assertion of the chosen action signal.\n"
		"- **Action12** (Display string: 'Action 12'): Starts with the assertion of the chosen action signal.\n"
		"- **Action13** (Display string: 'Action 13'): Starts with the assertion of the chosen action signal.\n"
		"- **Action14** (Display string: 'Action 14'): Starts with the assertion of the chosen action signal.\n"
		"- **Action15** (Display string: 'Action 15'): Starts with the assertion of the chosen action signal.\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): Starts with the reception of the Counter End.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): Starts with the reception of the Counter Start.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): Starts with the reception of the Counter End.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): Starts with the reception of the Counter Start.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): Starts with the reception of the Counter End.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): Starts with the reception of the Counter Start.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): Starts with the reception of the Counter End.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): Starts with the reception of the Counter End.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): Starts with the reception of the Counter End.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): Starts with the reception of the Counter End.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): Starts with the reception of the Counter End.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): Starts with the reception of the Counter End.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): Starts with the reception of the Counter End.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): Starts with the reception of the Counter End.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): Starts with the reception of the Counter End.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): Starts with the reception of the Counter End.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): Starts with the reception of the Counter End.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): Starts with the reception of the Counter End.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): Starts with the reception of the Counter End.\n"
		"- **Encoder0** (Display string: 'Encoder 0'): Starts with the reception of the Encoder output signal.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): Starts with the reception of the Encoder output signal.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): Starts with the reception of the Encoder output signal.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Starts with the reception of the Exposure End.\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Starts with the reception of the Exposure Start.\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Starts with the reception of the Frame Burst End.\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Starts with the reception of the Frame Burst Start.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Starts with the reception of the Frame End.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Starts with the reception of the Frame Start.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Starts with the reception of the Frame Start Trigger.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device has missed a Frame start trigger.\n"
		"- **Line0** (Display string: 'Line 0'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line1** (Display string: 'Line 1'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line2** (Display string: 'Line 2'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line3** (Display string: 'Line 3'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line4** (Display string: 'Line 4'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line5** (Display string: 'Line 5'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line6** (Display string: 'Line 6'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line7** (Display string: 'Line 7'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line8** (Display string: 'Line 8'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line9** (Display string: 'Line 9'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line10** (Display string: 'Line 10'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line11** (Display string: 'Line 11'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line12** (Display string: 'Line 12'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line13** (Display string: 'Line 13'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line14** (Display string: 'Line 14'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line15** (Display string: 'Line 15'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **LineEnd** (Display string: 'Line End'): Starts with the reception of the Line End.\n"
		"- **LineStart** (Display string: 'Line Start'): Starts with the reception of the Line Start.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Starts with the reception of the Line Start Trigger.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device has missed a Line start trigger.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): Starts with the reception of the chosen Link Trigger signal.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): Starts with the reception of the chosen Link Trigger signal.\n"
		"- **LinkTrigger2** (Display string: 'Link Trigger 2'): Starts with the reception of the chosen Link Trigger signal.\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): Starts with the reception of the Logic Block output signal.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): Starts with the reception of the Logic Block output signal.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): Starts with the reception of the Logic Block output signal.\n"
		"- **Off** (Display string: 'Off'): Disables the Counter trigger.\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): Starts on the reception of the Software Signal.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): Starts on the reception of the Software Signal.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): Starts on the reception of the Software Signal.\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): Starts with the reception of the Timer End.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): Starts with the reception of the Timer Start.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): Starts with the reception of the Timer End.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): Starts with the reception of the Timer Start.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): Starts with the reception of the Timer End.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): Starts with the reception of the Timer Start.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): Starts with the reception of the Timer End.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): Starts with the reception of the Timer End.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): Starts with the reception of the Timer End.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): Starts with the reception of the Timer End.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): Starts with the reception of the Timer End.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): Starts with the reception of the Timer End.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): Starts with the reception of the Timer End.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): Starts with the reception of the Timer End.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): Starts with the reception of the Timer End.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): Starts with the reception of the Timer End.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): Starts with the reception of the Timer End.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): Starts with the reception of the Timer End.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): Starts with the reception of the Timer End.\n"
		"- **UserOutput0** (Display string: 'User Output 0'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput1** (Display string: 'User Output 1'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput2** (Display string: 'User Output 2'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput3** (Display string: 'User Output 3'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput4** (Display string: 'User Output 4'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput5** (Display string: 'User Output 5'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput6** (Display string: 'User Output 6'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput7** (Display string: 'User Output 7'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput8** (Display string: 'User Output 8'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput9** (Display string: 'User Output 9'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput10** (Display string: 'User Output 10'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput11** (Display string: 'User Output 11'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput12** (Display string: 'User Output 12'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput13** (Display string: 'User Output 13'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput14** (Display string: 'User Output 14'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput15** (Display string: 'User Output 15'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')\n"
		"- **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')\n"
		"- **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')\n"
		"- **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')\n"
		"- **mvReadOutActive** (Display string: 'mv Read Out Active')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_counterTriggerActivation_get", _wrap_CounterAndTimerControl_counterTriggerActivation_get, METH_O, "\n"
		"An enumerated integer property. Selects the activation mode of the trigger to start the Counter.\n"
		"Selects the activation mode of the trigger to start the Counter.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RisingEdge** (Display string: 'Rising Edge'): Starts counting on the Rising Edge of the selected trigger signal.\n"
		"- **FallingEdge** (Display string: 'Falling Edge'): Starts counting on the Falling Edge of the selected trigger signal.\n"
		"- **AnyEdge** (Display string: 'Any Edge'): Starts counting on the Falling or rising Edge of the selected trigger signal.\n"
		"- **LevelHigh** (Display string: 'Level High'): Counts as long as the selected trigger signal level is High.\n"
		"- **LevelLow** (Display string: 'Level Low'): Counts as long as the selected trigger signal level is Low.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_timerSelector_get", _wrap_CounterAndTimerControl_timerSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Timer to configure.\n"
		"Selects which Timer to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Timer0** (Display string: 'Timer 0'): Selects the Timer 0.\n"
		"- **Timer1** (Display string: 'Timer 1'): Selects the Timer 1.\n"
		"- **Timer2** (Display string: 'Timer 2'): Selects the Timer 2.\n"
		"- **Timer3** (Display string: 'Timer 3'): Selects the Timer 3.\n"
		"- **Timer4** (Display string: 'Timer 4'): Selects the Timer 4.\n"
		"- **Timer5** (Display string: 'Timer 5'): Selects the Timer 5.\n"
		"- **Timer6** (Display string: 'Timer 6'): Selects the Timer 6.\n"
		"- **Timer7** (Display string: 'Timer 7'): Selects the Timer 7.\n"
		"- **Timer8** (Display string: 'Timer 8'): Selects the Timer 8.\n"
		"- **Timer9** (Display string: 'Timer 9'): Selects the Timer 9.\n"
		"- **Timer10** (Display string: 'Timer 10'): Selects the Timer 10.\n"
		"- **Timer11** (Display string: 'Timer 11'): Selects the Timer 11.\n"
		"- **Timer12** (Display string: 'Timer 12'): Selects the Timer 12.\n"
		"- **Timer13** (Display string: 'Timer 13'): Selects the Timer 13.\n"
		"- **Timer14** (Display string: 'Timer 14'): Selects the Timer 14.\n"
		"- **Timer15** (Display string: 'Timer 15'): Selects the Timer 15.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_timerDuration_get", _wrap_CounterAndTimerControl_timerDuration_get, METH_O, "\n"
		"A floating point property. Sets the duration (in microseconds) of the Timer pulse.\n"
		"Sets the duration (in microseconds) of the Timer pulse.\n"
		""},
	 { "CounterAndTimerControl_timerDelay_get", _wrap_CounterAndTimerControl_timerDelay_get, METH_O, "\n"
		"A floating point property. Sets the duration (in microseconds) of the delay to apply at the reception of a trigger before starting the Timer.\n"
		"Sets the duration (in microseconds) of the delay to apply at the reception of a trigger before starting the Timer.\n"
		""},
	 { "CounterAndTimerControl_timerReset_get", _wrap_CounterAndTimerControl_timerReset_get, METH_O, "\n"
		"A method object. Does a software reset of the selected timer and starts it.\n"
		"Does a software reset of the selected timer and starts it. The timer starts immediately after the reset unless a timer trigger is active.\n"
		""},
	 { "CounterAndTimerControl_timerValue_get", _wrap_CounterAndTimerControl_timerValue_get, METH_O, "\n"
		"A floating point property. Reads or writes the current value (in microseconds) of the selected Timer.\n"
		"Reads or writes the current value (in microseconds) of the selected Timer.\n"
		""},
	 { "CounterAndTimerControl_timerStatus_get", _wrap_CounterAndTimerControl_timerStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the current status of the Timer.\n"
		"Returns the current status of the Timer.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **TimerIdle** (Display string: 'Timer Idle'): The Timer is idle.\n"
		"- **TimerTriggerWait** (Display string: 'Timer Trigger Wait'): The Timer is waiting for a start trigger.\n"
		"- **TimerActive** (Display string: 'Timer Active'): The Timer is counting for the specified duration.\n"
		"- **TimerCompleted** (Display string: 'Timer Completed'): The Timer reached the TimerDuration count.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_timerTriggerSource_get", _wrap_CounterAndTimerControl_timerTriggerSource_get, METH_O, "\n"
		"An enumerated integer property. Selects the source of the trigger to start the Timer.\n"
		"Selects the source of the trigger to start the Timer.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Starts with the reception of the Acquisition End.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Starts with the reception of the Acquisition Start.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Starts with the reception of the Acquisition Trigger.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Starts with the reception of a missed Acquisition Trigger.\n"
		"- **Action0** (Display string: 'Action 0'): Starts with the assertion of the chosen action signal.\n"
		"- **Action1** (Display string: 'Action 1'): Starts with the assertion of the chosen action signal.\n"
		"- **Action2** (Display string: 'Action 2'): Starts with the assertion of the chosen action signal.\n"
		"- **Action3** (Display string: 'Action 3'): Starts with the assertion of the chosen action signal.\n"
		"- **Action4** (Display string: 'Action 4'): Starts with the assertion of the chosen action signal.\n"
		"- **Action5** (Display string: 'Action 5'): Starts with the assertion of the chosen action signal.\n"
		"- **Action6** (Display string: 'Action 6'): Starts with the assertion of the chosen action signal.\n"
		"- **Action7** (Display string: 'Action 7'): Starts with the assertion of the chosen action signal.\n"
		"- **Action8** (Display string: 'Action 8'): Starts with the assertion of the chosen action signal.\n"
		"- **Action9** (Display string: 'Action 9'): Starts with the assertion of the chosen action signal.\n"
		"- **Action10** (Display string: 'Action 10'): Starts with the assertion of the chosen action signal.\n"
		"- **Action11** (Display string: 'Action 11'): Starts with the assertion of the chosen action signal.\n"
		"- **Action12** (Display string: 'Action 12'): Starts with the assertion of the chosen action signal.\n"
		"- **Action13** (Display string: 'Action 13'): Starts with the assertion of the chosen action signal.\n"
		"- **Action14** (Display string: 'Action 14'): Starts with the assertion of the chosen action signal.\n"
		"- **Action15** (Display string: 'Action 15'): Starts with the assertion of the chosen action signal.\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): Starts with the reception of the Counter End.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): Starts with the reception of the Counter Start.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): Starts with the reception of the Counter End.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): Starts with the reception of the Counter Start.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): Starts with the reception of the Counter End.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): Starts with the reception of the Counter Start.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): Starts with the reception of the Counter End.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): Starts with the reception of the Counter End.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): Starts with the reception of the Counter End.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): Starts with the reception of the Counter End.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): Starts with the reception of the Counter End.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): Starts with the reception of the Counter End.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): Starts with the reception of the Counter End.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): Starts with the reception of the Counter End.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): Starts with the reception of the Counter End.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): Starts with the reception of the Counter End.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): Starts with the reception of the Counter End.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): Starts with the reception of the Counter End.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): Starts with the reception of the Counter End.\n"
		"- **Encoder0** (Display string: 'Encoder 0'): Starts with the reception of the Encoder output signal.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): Starts with the reception of the Encoder output signal.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): Starts with the reception of the Encoder output signal.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Starts with the reception of the Exposure End.\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Starts with the reception of the Exposure Start.\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Starts with the reception of the Frame Burst End.\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Starts with the reception of the Frame Burst Start.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Starts with the reception of the Frame End.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Starts with the reception of the Frame Start.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Starts with the reception of the Frame Start Trigger.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Starts with the reception of a missed Frame Trigger.\n"
		"- **Line0** (Display string: 'Line 0'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line1** (Display string: 'Line 1'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line2** (Display string: 'Line 2'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line3** (Display string: 'Line 3'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line4** (Display string: 'Line 4'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line5** (Display string: 'Line 5'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line6** (Display string: 'Line 6'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line7** (Display string: 'Line 7'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line8** (Display string: 'Line 8'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line9** (Display string: 'Line 9'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line10** (Display string: 'Line 10'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line11** (Display string: 'Line 11'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line12** (Display string: 'Line 12'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line13** (Display string: 'Line 13'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line14** (Display string: 'Line 14'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line15** (Display string: 'Line 15'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **LineEnd** (Display string: 'Line End'): Starts with the reception of the Line End.\n"
		"- **LineStart** (Display string: 'Line Start'): Starts with the reception of the Line Start.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Starts with the reception of the Line Start Trigger.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Starts with the reception of a missed Line Trigger.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): Starts with the reception of the chosen Link Trigger.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): Starts with the reception of the chosen Link Trigger.\n"
		"- **LinkTrigger2** (Display string: 'Link Trigger 2'): Starts with the reception of the chosen Link Trigger.\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): Starts with the reception of the Logic Block output signal.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): Starts with the reception of the Logic Block output signal.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): Starts with the reception of the Logic Block output signal.\n"
		"- **Off** (Display string: 'Off'): Disables the Timer trigger.\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): Starts on the reception of the Software Signal.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): Starts on the reception of the Software Signal.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): Starts on the reception of the Software Signal.\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): Starts with the reception of the Timer Start.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): Starts with the reception of the Timer Start.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): Starts with the reception of the Timer Start.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.\n"
		"- **UserOutput0** (Display string: 'User Output 0'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput1** (Display string: 'User Output 1'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput2** (Display string: 'User Output 2'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput3** (Display string: 'User Output 3'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput4** (Display string: 'User Output 4'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput5** (Display string: 'User Output 5'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput6** (Display string: 'User Output 6'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput7** (Display string: 'User Output 7'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')\n"
		"- **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')\n"
		"- **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')\n"
		"- **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_timerTriggerActivation_get", _wrap_CounterAndTimerControl_timerTriggerActivation_get, METH_O, "\n"
		"An enumerated integer property. Selects the activation mode of the trigger to start the Timer.\n"
		"Selects the activation mode of the trigger to start the Timer.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RisingEdge** (Display string: 'Rising Edge'): Starts counting on the Rising Edge of the selected trigger signal.\n"
		"- **FallingEdge** (Display string: 'Falling Edge'): Starts counting on the Falling Edge of the selected trigger signal.\n"
		"- **AnyEdge** (Display string: 'Any Edge'): Starts counting on the Falling or Rising Edge of the selected trigger signal.\n"
		"- **LevelHigh** (Display string: 'Level High'): Counts as long as the selected trigger signal level is High.\n"
		"- **LevelLow** (Display string: 'Level Low'): Counts as long as the selected trigger signal level is Low.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "CounterAndTimerControl_timerTriggerArmDelay_get", _wrap_CounterAndTimerControl_timerTriggerArmDelay_get, METH_O, "\n"
		"A floating point property. Sets the minimum period between two valid timer triggers.\n"
		"Sets the minimum period between two valid timer triggers.\n"
		""},
	 { "delete_CounterAndTimerControl", _wrap_delete_CounterAndTimerControl, METH_O, NULL},
	 { "CounterAndTimerControl_swigregister", CounterAndTimerControl_swigregister, METH_O, NULL},
	 { "CounterAndTimerControl_swiginit", CounterAndTimerControl_swiginit, METH_VARARGS, NULL},
	 { "new_EncoderControl", _wrap_new_EncoderControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::EncoderControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "EncoderControl_encoderSelector_get", _wrap_EncoderControl_encoderSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Encoder to configure.\n"
		"Selects which Encoder to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Encoder0** (Display string: 'Encoder 0'): Selects Encoder 0.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): Selects Encoder 1.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): Selects Encoder 2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "EncoderControl_encoderSourceA_get", _wrap_EncoderControl_encoderSourceA_get, METH_O, "\n"
		"An enumerated integer property. Selects the signal which will be the source of the A input of the Encoder.\n"
		"Selects the signal which will be the source of the A input of the Encoder.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Line0** (Display string: 'Line 0'): Encoder Forward input is taken from the chosen I/O Line.\n"
		"- **Line1** (Display string: 'Line 1'): Encoder Forward input is taken from the chosen I/O Line.\n"
		"- **Line2** (Display string: 'Line 2'): Encoder Forward input is taken from the chosen I/O Line.\n"
		"- **Off** (Display string: 'Off'): Counter is stopped.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "EncoderControl_encoderSourceB_get", _wrap_EncoderControl_encoderSourceB_get, METH_O, "\n"
		"An enumerated integer property. Selects the signal which will be the source of the B input of the Encoder.\n"
		"Selects the signal which will be the source of the B input of the Encoder.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Line0** (Display string: 'Line 0'): Encoder Reverse input is taken from the chosen I/O Line.\n"
		"- **Line1** (Display string: 'Line 1'): Encoder Reverse input is taken from the chosen I/O Line.\n"
		"- **Line2** (Display string: 'Line 2'): Encoder Reverse input is taken from the chosen I/O Line.\n"
		"- **Off** (Display string: 'Off'): Counter is stopped.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "EncoderControl_encoderMode_get", _wrap_EncoderControl_encoderMode_get, METH_O, "\n"
		"An enumerated integer property. Selects if the count of encoder uses FourPhase mode with jitter filtering or the HighResolution mode without jitter filtering.\n"
		"Selects if the count of encoder uses FourPhase mode with jitter filtering or the HighResolution mode without jitter filtering.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **FourPhase** (Display string: 'Four Phase'): The counter increments or decrements 1 for every full quadrature cycle with jitter filtering.\n"
		"- **HighResolution** (Display string: 'High Resolution'): The counter increments or decrements every quadrature phase for high resolution counting, but without jitter filtering.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "EncoderControl_encoderDivider_get", _wrap_EncoderControl_encoderDivider_get, METH_O, "\n"
		"An integer property. Sets how many Encoder increments/decrements are needed to generate an Encoder output pulse signal.\n"
		"Sets how many Encoder increments/decrements are needed to generate an Encoder output pulse signal.\n"
		""},
	 { "EncoderControl_encoderOutputMode_get", _wrap_EncoderControl_encoderOutputMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the conditions for the Encoder interface to generate a valid Encoder output signal.\n"
		"Selects the conditions for the Encoder interface to generate a valid Encoder output signal.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): No output pulse are generated.\n"
		"- **PositionUp** (Display string: 'Position Up'): Output pulses are generated at all new positions in the positive direction. If the encoder reverses no output pulse are generated until it has again passed the position where the reversal started.\n"
		"- **PositionDown** (Display string: 'Position Down'): Output pulses are generated at all new positions in the negative direction. If the encoder reverses no output pulse are generated until it has again passed the position where the reversal started.\n"
		"- **DirectionUp** (Display string: 'Direction Up'): Output pulses are generated at all position increments in the positive direction while ignoring negative direction motion.\n"
		"- **DirectionDown** (Display string: 'Direction Down'): Output pulses are generated at all position increments in the negative direction while ignoring positive direction motion.\n"
		"- **Motion** (Display string: 'Motion'): Output pulses are generated at all motion increments in both directions.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		"\n"
		"The following figure explains the different **encoderOutputModes**\n"
		"\n"
		"\n"
		"   Image: EventControl.png\n"
		"    encoderOutputModes\n"
		"\n"
		""},
	 { "EncoderControl_encoderStatus_get", _wrap_EncoderControl_encoderStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the motion status of the encoder.\n"
		"Returns the motion status of the encoder.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **EncoderUp** (Display string: 'Encoder Up'): The encoder counter last incremented.\n"
		"- **EncoderDown** (Display string: 'Encoder Down'): The encoder counter last decremented.\n"
		"- **EncoderIdle** (Display string: 'Encoder Idle'): The encoder is not active.\n"
		"- **EncoderStatic** (Display string: 'Encoder Static'): No motion within the EncoderTimeout time.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "EncoderControl_encoderTimeout_get", _wrap_EncoderControl_encoderTimeout_get, METH_O, "\n"
		"A floating point property. Sets the maximum time interval between encoder counter increments before the status turns to static.\n"
		"Sets the maximum time interval between encoder counter increments before the status turns to static.\n"
		""},
	 { "EncoderControl_encoderResetSource_get", _wrap_EncoderControl_encoderResetSource_get, METH_O, "\n"
		"An enumerated integer property. Selects the signals that will be the source to reset the Encoder.\n"
		"Selects the signals that will be the source to reset the Encoder.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Resets with the reception of the Acquisition End.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Resets with the reception of the Acquisition Start.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Resets with the reception of the Acquisition Trigger.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Resets with the reception of a missed Acquisition Trigger.\n"
		"- **Action0** (Display string: 'Action 0'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action1** (Display string: 'Action 1'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Action2** (Display string: 'Action 2'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): Resets with the reception of the Counter End.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): Resets with the reception of the Counter Start.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): Resets with the reception of the Counter End.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): Resets with the reception of the Counter Start.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): Resets with the reception of the Counter End.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): Resets with the reception of the Counter Start.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Resets with the reception of the Exposure End.\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Resets with the reception of the Exposure Start.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Resets with the reception of the Frame End.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Resets with the reception of the Frame Start.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Resets with the reception of the Frame Start Trigger.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Resets with the reception of a missed Frame Trigger.\n"
		"- **Line0** (Display string: 'Line 0'): Resets by the chosen I/O Line.\n"
		"- **Line1** (Display string: 'Line 1'): Resets by the chosen I/O Line.\n"
		"- **Line2** (Display string: 'Line 2'): Resets by the chosen I/O Line.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): Resets on the reception of the chosen Link Trigger (received from the transport layer).\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): Resets on the reception of the chosen Link Trigger (received from the transport layer).\n"
		"- **LinkTrigger2** (Display string: 'Link Trigger 2'): Resets on the reception of the chosen Link Trigger (received from the transport layer).\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): Reset by the choosen Logic Block signal.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): Reset by the choosen Logic Block signal.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): Reset by the choosen Logic Block signal.\n"
		"- **Off** (Display string: 'Off'): Disable the Encoder Reset trigger.\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): Resets on the reception of the Software Signal.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): Resets on the reception of the Software Signal.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): Resets on the reception of the Software Signal.\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): Resets with the reception of the Timer End.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): Resets with the reception of the Timer Start.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): Resets with the reception of the Timer End.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): Resets with the reception of the Timer Start.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): Resets with the reception of the Timer End.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): Resets with the reception of the Timer Start.\n"
		"- **UserOutput0** (Display string: 'User Output 0'): Resets by the chosen User Output bit.\n"
		"- **UserOutput1** (Display string: 'User Output 1'): Resets by the chosen User Output bit.\n"
		"- **UserOutput2** (Display string: 'User Output 2'): Resets by the chosen User Output bit.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "EncoderControl_encoderResetActivation_get", _wrap_EncoderControl_encoderResetActivation_get, METH_O, "\n"
		"An enumerated integer property. Selects the Activation mode of the Encoder Reset Source signal.\n"
		"Selects the Activation mode of the Encoder Reset Source signal.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RisingEdge** (Display string: 'Rising Edge'): Resets the Encoder on the Rising Edge of the signal.\n"
		"- **FallingEdge** (Display string: 'Falling Edge'): Resets the Encoder on the Falling Edge of the signal.\n"
		"- **AnyEdge** (Display string: 'Any Edge'): Resets the Encoder on the Falling or rising Edge of the selected signal.\n"
		"- **LevelHigh** (Display string: 'Level High'): Resets the Encoder as long as the selected signal level is High.\n"
		"- **LevelLow** (Display string: 'Level Low'): Resets the Encoder as long as the selected signal level is Low.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "EncoderControl_encoderReset_get", _wrap_EncoderControl_encoderReset_get, METH_O, "\n"
		"A method object. Does a software reset of the selected Encoder and starts it.\n"
		"Does a software reset of the selected Encoder and starts it. The Encoder starts counting events immediately after the reset. EncoderReset can be used to reset the Encoder independently from the EncoderResetSource.\n"
		""},
	 { "EncoderControl_encoderValue_get", _wrap_EncoderControl_encoderValue_get, METH_O, "\n"
		"An integer property. Reads or writes the current value of the position counter of the selected Encoder.\n"
		"Reads or writes the current value of the position counter of the selected Encoder.\n"
		""},
	 { "EncoderControl_encoderValueAtReset_get", _wrap_EncoderControl_encoderValueAtReset_get, METH_O, "\n"
		"An integer property. Reads the value of the of the position counter of the selected Encoder when it was reset by a signal or by an explicit EncoderReset command.\n"
		"Reads the value of the of the position counter of the selected Encoder when it was reset by a signal or by an explicit EncoderReset command.\n"
		""},
	 { "EncoderControl_encoderResolution_get", _wrap_EncoderControl_encoderResolution_get, METH_O, "\n"
		"A floating point property. Defines the resolution of one encoder step.\n"
		"Defines the resolution of one encoder step.\n"
		""},
	 { "delete_EncoderControl", _wrap_delete_EncoderControl, METH_O, NULL},
	 { "EncoderControl_swigregister", EncoderControl_swigregister, METH_O, NULL},
	 { "EncoderControl_swiginit", EncoderControl_swiginit, METH_VARARGS, NULL},
	 { "new_LogicBlockControl", _wrap_new_LogicBlockControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::LogicBlockControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "LogicBlockControl_logicBlockSelector_get", _wrap_LogicBlockControl_logicBlockSelector_get, METH_O, "\n"
		"An enumerated integer property. Specifies the Logic Block to configure.\n"
		"Specifies the Logic Block to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): Logic Block 0 is selected.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): Logic Block 1 is selected.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): Logic Block 2 is selected.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "LogicBlockControl_logicBlockFunction_get", _wrap_LogicBlockControl_logicBlockFunction_get, METH_O, "\n"
		"An enumerated integer property. Selects the combinational logic Function of the Logic Block to configure.\n"
		"Selects the combinational logic Function of the Logic Block to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AND** (Display string: 'AND'): Selects a Logic Block that does the logical AND of all the inputs.\n"
		"- **OR** (Display string: 'OR'): Selects a Logic Block that does the logical OR of all the inputs.\n"
		"- **LUT** (Display string: 'LUT'): Selects a Logic Block that does a Look Up Table Transformation on all the inputs.\n"
		"- **LatchedLUT** (Display string: 'Latched LUT'): Selects a Logic Block with 2 LUTs as inputs to a Flip-Flop.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "LogicBlockControl_logicBlockInputNumber_get", _wrap_LogicBlockControl_logicBlockInputNumber_get, METH_O, "\n"
		"An integer property. Specifies the number of active signal inputs of the Logic Block.\n"
		"Specifies the number of active signal inputs of the Logic Block.\n"
		""},
	 { "LogicBlockControl_logicBlockInputSelector_get", _wrap_LogicBlockControl_logicBlockInputSelector_get, METH_O, "\n"
		"An integer property. Selects the Logic Block's input to configure.\n"
		"Selects the Logic Block's input to configure.\n"
		""},
	 { "LogicBlockControl_logicBlockInputSource_get", _wrap_LogicBlockControl_logicBlockInputSource_get, METH_O, "\n"
		"An enumerated integer property. Selects the source signal for the input into the Logic Block.\n"
		"Selects the source signal for the input into the Logic Block. True or False indicates the input is forced constant.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionActive** (Display string: 'Acquisition Active'): Device is acquiring one or many Frames.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device is currently waiting for a trigger for the capture of one or many Frames.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device has missed a trigger for the capture of one or many Frames.\n"
		"- **AcquisitionTriggerWait** (Display string: 'Acquisition Trigger Wait'): Device is currently waiting for a trigger for the capture of one or many Frames.\n"
		"- **Counter0Active** (Display string: 'Counter 0 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter1Active** (Display string: 'Counter 1 Active'): The chosen counter is in active state (counting).\n"
		"- **Counter2Active** (Display string: 'Counter 2 Active'): The chosen counter is in active state (counting).\n"
		"- **Encoder0** (Display string: 'Encoder 0'): The chosen Encoder Output state.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): The chosen Encoder Output state.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): The chosen Encoder Output state.\n"
		"- **ExposureActive** (Display string: 'Exposure Active'): Device is doing the exposure of a Frame (or Line).\n"
		"- **False** (Display string: 'False'): Logic Block input is forced to Zero.\n"
		"- **FrameActive** (Display string: 'Frame Active'): Device is currently doing the capture of a Frame.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Device is currently waiting for a Frame start trigger.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device has missed a Frame start trigger.\n"
		"- **FrameTriggerWait** (Display string: 'Frame Trigger Wait'): Device is currently waiting for a Frame start trigger.\n"
		"- **Line0** (Display string: 'Line 0'): The chosen I/OLine state.\n"
		"- **Line1** (Display string: 'Line 1'): The chosen I/OLine state.\n"
		"- **Line2** (Display string: 'Line 2'): The chosen I/OLine state.\n"
		"- **LineActive** (Display string: 'Line Active'): Device is currently doing the capture of a Line.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Device is currently waiting for a Line start trigger.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device has missed a Line start trigger.\n"
		"- **LineTriggerWait** (Display string: 'Line Trigger Wait'): Device is currently waiting for a Line start trigger.\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): The choosen Logic Block output state.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): The choosen Logic Block output state.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): The choosen Logic Block output state.\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): The choosen Software Signal output state.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): The choosen Software Signal output state.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): The choosen Software Signal output state.\n"
		"- **Stream0TransferActive** (Display string: 'Stream 0 Transfer Active'): Transfer on the stream is active.\n"
		"- **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Transfer on the stream is in overflow.\n"
		"- **Stream0TransferPaused** (Display string: 'Stream 0 Transfer Paused'): Transfer on the stream is paused.\n"
		"- **Stream0TransferStopped** (Display string: 'Stream 0 Transfer Stopped'): Transfer on the stream is stopped.\n"
		"- **Stream0TransferStopping** (Display string: 'Stream 0 Transfer Stopping'): Transfer on the stream is stopping.\n"
		"- **Stream1TransferActive** (Display string: 'Stream 1 Transfer Active'): Transfer on the stream is active.\n"
		"- **Stream1TransferOverflow** (Display string: 'Stream 1 Transfer Overflow'): Transfer on the stream is in overflow.\n"
		"- **Stream1TransferPaused** (Display string: 'Stream 1 Transfer Paused'): Transfer on the stream is paused.\n"
		"- **Stream1TransferStopped** (Display string: 'Stream 1 Transfer Stopped'): Transfer on the stream is stopped.\n"
		"- **Stream1TransferStopping** (Display string: 'Stream 1 Transfer Stopping'): Transfer on the stream is stopping.\n"
		"- **Timer0Active** (Display string: 'Timer 0 Active'): The chosen Timer is in active state.\n"
		"- **Timer1Active** (Display string: 'Timer 1 Active'): The chosen Timer is in active state.\n"
		"- **Timer2Active** (Display string: 'Timer 2 Active'): The chosen Timer is in active state.\n"
		"- **True** (Display string: 'True'): Logic Block input is forced to One.\n"
		"- **UserOutput0** (Display string: 'User Output 0'): The chosen User Output bit state as defined by its current UserOutputValue.\n"
		"- **UserOutput1** (Display string: 'User Output 1'): The chosen User Output bit state as defined by its current UserOutputValue.\n"
		"- **UserOutput2** (Display string: 'User Output 2'): The chosen User Output bit state as defined by its current UserOutputValue.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "LogicBlockControl_logicBlockInputInverter_get", _wrap_LogicBlockControl_logicBlockInputInverter_get, METH_O, "\n"
		"A boolean property. Selects if the selected Logic Block Input source signal is inverted.\n"
		"Selects if the selected Logic Block Input source signal is inverted. This feature is not available when the LogicBlockInputSource is set to True or False.\n"
		""},
	 { "LogicBlockControl_logicBlockLUTIndex_get", _wrap_LogicBlockControl_logicBlockLUTIndex_get, METH_O, "\n"
		"An integer property. Controls the index of the truth table to access in the selected LUT.\n"
		"Controls the index of the truth table to access in the selected LUT.\n"
		""},
	 { "LogicBlockControl_logicBlockLUTValue_get", _wrap_LogicBlockControl_logicBlockLUTValue_get, METH_O, "\n"
		"A boolean property. Read or Write the Value associated with the entry at index LogicBlockLUTIndex of the selected LUT.\n"
		"Read or Write the Value associated with the entry at index LogicBlockLUTIndex of the selected LUT.\n"
		""},
	 { "LogicBlockControl_logicBlockLUTValueAll_get", _wrap_LogicBlockControl_logicBlockLUTValueAll_get, METH_O, "\n"
		"An integer property. Sets the values of all the output bits of the selected LUT in one access ignoring LogicBlockLUTIndex.\n"
		"Sets the values of all the output bits of the selected LUT in one access ignoring LogicBlockLUTIndex. LogicBlockLUTValueAll value can be any binary number and each bit correspond to the output value for the corresponding index (i.e. Bit 0 = LUT Index 0 output binary value).\n"
		""},
	 { "LogicBlockControl_logicBlockLUTSelector_get", _wrap_LogicBlockControl_logicBlockLUTSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which of the two LUTs to configure when the selected Logic Block is a Latched dual LUTs (i.e: LogicalBlockFunction = LatchedLUT).\n"
		"Selects which of the two LUTs to configure when the selected Logic Block is a Latched dual LUTs (i.e: LogicalBlockFunction = LatchedLUT).\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Value** (Display string: 'Value'): Selects the LUT controlling the data input of the flip-flop.\n"
		"- **Enable** (Display string: 'Enable'): Selects the LUT controlling the enable input of the flip-flop.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_LogicBlockControl", _wrap_delete_LogicBlockControl, METH_O, NULL},
	 { "LogicBlockControl_swigregister", LogicBlockControl_swigregister, METH_O, NULL},
	 { "LogicBlockControl_swiginit", LogicBlockControl_swiginit, METH_VARARGS, NULL},
	 { "new_SoftwareSignalControl", _wrap_new_SoftwareSignalControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::SoftwareSignalControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "SoftwareSignalControl_softwareSignalSelector_get", _wrap_SoftwareSignalControl_softwareSignalSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Software Signal features to control.\n"
		"Selects which Software Signal features to control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): Selects the software generated signal to control.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): Selects the software generated signal to control.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): Selects the software generated signal to control.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SoftwareSignalControl_softwareSignalPulse_get", _wrap_SoftwareSignalControl_softwareSignalPulse_get, METH_O, "\n"
		"A method object. Generates a pulse signal that can be used as a software trigger.\n"
		"Generates a pulse signal that can be used as a software trigger. This command can be used to trigger other modules that accept a SoftwareSignal as trigger source.\n"
		""},
	 { "delete_SoftwareSignalControl", _wrap_delete_SoftwareSignalControl, METH_O, NULL},
	 { "SoftwareSignalControl_swigregister", SoftwareSignalControl_swigregister, METH_O, NULL},
	 { "SoftwareSignalControl_swiginit", SoftwareSignalControl_swiginit, METH_VARARGS, NULL},
	 { "new_ActionControl", _wrap_new_ActionControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::ActionControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "ActionControl_actionUnconditionalMode_get", _wrap_ActionControl_actionUnconditionalMode_get, METH_O, "\n"
		"An enumerated integer property. Enables the unconditional action command mode where action commands are processed even when the primary control channel is closed.\n"
		"Enables the unconditional action command mode where action commands are processed even when the primary control channel is closed.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Unconditional mode is disabled.\n"
		"- **On** (Display string: 'On'): Unconditional mode is enabled.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ActionControl_actionDeviceKey_get", _wrap_ActionControl_actionDeviceKey_get, METH_O, "\n"
		"An integer property. Provides the device key that allows the device to check the validity of action commands.\n"
		"Provides the device key that allows the device to check the validity of action commands. The device internal assertion of an action signal is only authorized if the ActionDeviceKey and the action device key value in the protocol message are equal.\n"
		""},
	 { "ActionControl_actionQueueSize_get", _wrap_ActionControl_actionQueueSize_get, METH_O, "\n"
		"An integer property. Indicates the size of the scheduled action commands queue.\n"
		"Indicates the size of the scheduled action commands queue. This number represents the maximum number of scheduled action commands that can be pending at a given point in time.\n"
		""},
	 { "ActionControl_actionSelector_get", _wrap_ActionControl_actionSelector_get, METH_O, "\n"
		"An integer property. Selects to which Action Signal further Action settings apply.\n"
		"Selects to which Action Signal further Action settings apply.\n"
		""},
	 { "ActionControl_actionGroupMask_get", _wrap_ActionControl_actionGroupMask_get, METH_O, "\n"
		"An integer property. Provides the mask that the device will use to validate the action on reception of the action protocol message.\n"
		"Provides the mask that the device will use to validate the action on reception of the action protocol message.\n"
		""},
	 { "ActionControl_actionGroupKey_get", _wrap_ActionControl_actionGroupKey_get, METH_O, "\n"
		"An integer property. Provides the key that the device will use to validate the action on reception of the action protocol message.\n"
		"Provides the key that the device will use to validate the action on reception of the action protocol message.\n"
		""},
	 { "delete_ActionControl", _wrap_delete_ActionControl, METH_O, NULL},
	 { "ActionControl_swigregister", ActionControl_swigregister, METH_O, NULL},
	 { "ActionControl_swiginit", ActionControl_swiginit, METH_VARARGS, NULL},
	 { "new_EventControl", _wrap_new_EventControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::EventControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "EventControl_eventSelector_get", _wrap_EventControl_eventSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Event to signal to the host application.\n"
		"Selects which Event to signal to the host application.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.\n"
		"- **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.\n"
		"- **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.\n"
		"- **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.\n"
		"- **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.\n"
		"- **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.\n"
		"- **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.\n"
		"- **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).\n"
		"- **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.\n"
		"- **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.\n"
		"- **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.\n"
		"- **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.\n"
		"- **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.\n"
		"- **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.\n"
		"- **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.\n"
		"- **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.\n"
		"- **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.\n"
		"- **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.\n"
		"- **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.\n"
		"- **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.\n"
		"- **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.\n"
		"- **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.\n"
		"- **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.\n"
		"- **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.\n"
		"- **DeviceTemperatureStateCritical** (Display string: 'Device Temperature State Critical')\n"
		"- **DeviceTemperatureStateNormal** (Display string: 'Device Temperature State Normal')\n"
		"- **DeviceTemperatureStateOverTemperature** (Display string: 'Device Temperature State Over Temperature')\n"
		"- **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.\n"
		"- **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.\n"
		"- **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.\n"
		"- **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.\n"
		"- **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.\n"
		"- **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.\n"
		"- **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.\n"
		"- **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.\n"
		"- **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.\n"
		"- **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.\n"
		"- **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.\n"
		"- **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.\n"
		"- **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.\n"
		"- **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.\n"
		"- **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.\n"
		"- **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.\n"
		"- **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.\n"
		"- **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.\n"
		"- **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.\n"
		"- **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.\n"
		"- **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.\n"
		"- **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.\n"
		"- **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.\n"
		"- **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.\n"
		"- **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.\n"
		"- **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.\n"
		"- **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.\n"
		"- **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.\n"
		"- **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.\n"
		"- **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.\n"
		"- **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.\n"
		"- **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.\n"
		"- **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.\n"
		"- **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.\n"
		"- **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.\n"
		"- **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.\n"
		"- **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.\n"
		"- **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.\n"
		"- **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.\n"
		"- **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.\n"
		"- **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.\n"
		"- **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.\n"
		"- **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.\n"
		"- **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.\n"
		"- **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.\n"
		"- **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.\n"
		"- **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.\n"
		"- **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.\n"
		"- **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.\n"
		"- **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.\n"
		"- **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.\n"
		"- **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.\n"
		"- **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.\n"
		"- **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.\n"
		"- **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.\n"
		"- **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.\n"
		"- **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.\n"
		"- **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.\n"
		"- **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.\n"
		"- **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.\n"
		"- **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.\n"
		"- **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.\n"
		"- **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.\n"
		"- **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.\n"
		"- **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.\n"
		"- **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.\n"
		"- **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.\n"
		"- **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.\n"
		"- **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.\n"
		"- **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.\n"
		"- **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.\n"
		"- **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.\n"
		"- **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.\n"
		"- **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.\n"
		"- **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.\n"
		"- **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.\n"
		"- **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.\n"
		"- **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.\n"
		"- **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.\n"
		"- **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.\n"
		"- **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.\n"
		"- **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.\n"
		"- **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.\n"
		"- **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.\n"
		"- **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.\n"
		"- **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.\n"
		"- **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.\n"
		"- **Link0Trigger** (Display string: 'Link 0 Trigger')\n"
		"- **Link1Trigger** (Display string: 'Link 1 Trigger')\n"
		"- **Link2Trigger** (Display string: 'Link 2 Trigger')\n"
		"- **Link3Trigger** (Display string: 'Link 3 Trigger')\n"
		"- **Link4Trigger** (Display string: 'Link 4 Trigger')\n"
		"- **Link5Trigger** (Display string: 'Link 5 Trigger')\n"
		"- **Link6Trigger** (Display string: 'Link 6 Trigger')\n"
		"- **Link7Trigger** (Display string: 'Link 7 Trigger')\n"
		"- **Link8Trigger** (Display string: 'Link 8 Trigger')\n"
		"- **Link9Trigger** (Display string: 'Link 9 Trigger')\n"
		"- **Link10Trigger** (Display string: 'Link 10 Trigger')\n"
		"- **Link11Trigger** (Display string: 'Link 11 Trigger')\n"
		"- **Link12Trigger** (Display string: 'Link 12 Trigger')\n"
		"- **Link13Trigger** (Display string: 'Link 13 Trigger')\n"
		"- **Link14Trigger** (Display string: 'Link 14 Trigger')\n"
		"- **Link15Trigger** (Display string: 'Link 15 Trigger')\n"
		"- **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.\n"
		"- **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).\n"
		"- **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.\n"
		"- **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.\n"
		"- **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.\n"
		"- **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.\n"
		"- **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.\n"
		"- **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.\n"
		"- **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.\n"
		"- **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.\n"
		"- **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.\n"
		"- **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.\n"
		"- **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.\n"
		"- **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.\n"
		"- **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.\n"
		"- **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.\n"
		"- **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.\n"
		"- **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.\n"
		"- **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.\n"
		"- **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.\n"
		"- **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.\n"
		"- **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.\n"
		"- **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.\n"
		"- **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.\n"
		"- **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.\n"
		"- **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.\n"
		"- **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "EventControl_eventNotification_get", _wrap_EventControl_eventNotification_get, METH_O, "\n"
		"An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The selected Event notification is disabled.\n"
		"- **On** (Display string: 'On'): The selected Event notification is enabled.\n"
		"- **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.\n"
		"- **GigEVisionEvent** (Display string: 'Gig E Vision Event')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "EventControl_eventAcquisitionTrigger_get", _wrap_EventControl_eventAcquisitionTrigger_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Acquisition Trigger type of Event.\n"
		"Returns the unique Identifier of the Acquisition Trigger type of Event.\n"
		""},
	 { "EventControl_eventAcquisitionTriggerTimestamp_get", _wrap_EventControl_eventAcquisitionTriggerTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Acquisition Trigger Event.\n"
		"Returns the Timestamp of the Acquisition Trigger Event.\n"
		""},
	 { "EventControl_eventAcquisitionTriggerFrameID_get", _wrap_EventControl_eventAcquisitionTriggerFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Trigger Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Acquisition Trigger Event.\n"
		""},
	 { "EventControl_eventAcquisitionTriggerMissed_get", _wrap_EventControl_eventAcquisitionTriggerMissed_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Acquisition Trigger Missed type of Event.\n"
		"Returns the unique Identifier of the Acquisition Trigger Missed type of Event.\n"
		""},
	 { "EventControl_eventAcquisitionTriggerMissedTimestamp_get", _wrap_EventControl_eventAcquisitionTriggerMissedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Acquisition Trigger Missed Event.\n"
		"Returns the Timestamp of the Acquisition Trigger Missed Event.\n"
		""},
	 { "EventControl_eventAcquisitionTriggerMissedFrameID_get", _wrap_EventControl_eventAcquisitionTriggerMissedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Trigger Missed Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Acquisition Trigger Missed Event.\n"
		""},
	 { "EventControl_eventAcquisitionStart_get", _wrap_EventControl_eventAcquisitionStart_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Acquisition Start type of Event.\n"
		"Returns the unique Identifier of the Acquisition Start type of Event.\n"
		""},
	 { "EventControl_eventAcquisitionStartTimestamp_get", _wrap_EventControl_eventAcquisitionStartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Acquisition Start Event.\n"
		"Returns the Timestamp of the Acquisition Start Event.\n"
		""},
	 { "EventControl_eventAcquisitionStartFrameID_get", _wrap_EventControl_eventAcquisitionStartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Acquisition Start Event.\n"
		""},
	 { "EventControl_eventAcquisitionEnd_get", _wrap_EventControl_eventAcquisitionEnd_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Acquisition End type of Event.\n"
		"Returns the unique Identifier of the Acquisition End type of Event.\n"
		""},
	 { "EventControl_eventAcquisitionEndTimestamp_get", _wrap_EventControl_eventAcquisitionEndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Acquisition End Event.\n"
		"Returns the Timestamp of the Acquisition End Event.\n"
		""},
	 { "EventControl_eventAcquisitionEndFrameID_get", _wrap_EventControl_eventAcquisitionEndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Acquisition End Event.\n"
		""},
	 { "EventControl_eventAcquisitionTransferStart_get", _wrap_EventControl_eventAcquisitionTransferStart_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Acquisition Transfer Start type of Event.\n"
		"Returns the unique Identifier of the Acquisition Transfer Start type of Event.\n"
		""},
	 { "EventControl_eventAcquisitionTransferStartTimestamp_get", _wrap_EventControl_eventAcquisitionTransferStartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Acquisition Transfer Start Event.\n"
		"Returns the Timestamp of the Acquisition Transfer Start Event.\n"
		""},
	 { "EventControl_eventAcquisitionTransferStartFrameID_get", _wrap_EventControl_eventAcquisitionTransferStartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Transfer Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Acquisition Transfer Start Event.\n"
		""},
	 { "EventControl_eventAcquisitionTransferEnd_get", _wrap_EventControl_eventAcquisitionTransferEnd_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Acquisition Transfer End type of Event.\n"
		"Returns the unique Identifier of the Acquisition Transfer End type of Event.\n"
		""},
	 { "EventControl_eventAcquisitionTransferEndTimestamp_get", _wrap_EventControl_eventAcquisitionTransferEndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Acquisition Transfer End Event.\n"
		"Returns the Timestamp of the Acquisition Transfer End Event.\n"
		""},
	 { "EventControl_eventAcquisitionTransferEndFrameID_get", _wrap_EventControl_eventAcquisitionTransferEndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Transfer End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Acquisition Transfer End Event.\n"
		""},
	 { "EventControl_eventAcquisitionError_get", _wrap_EventControl_eventAcquisitionError_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Acquisition Error type of Event.\n"
		"Returns the unique Identifier of the Acquisition Error type of Event.\n"
		""},
	 { "EventControl_eventAcquisitionErrorTimestamp_get", _wrap_EventControl_eventAcquisitionErrorTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Acquisition Error Event.\n"
		"Returns the Timestamp of the Acquisition Error Event.\n"
		""},
	 { "EventControl_eventAcquisitionErrorFrameID_get", _wrap_EventControl_eventAcquisitionErrorFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Error Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Acquisition Error Event.\n"
		""},
	 { "EventControl_eventFrameBurstStart_get", _wrap_EventControl_eventFrameBurstStart_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame Burst Start type of Event.\n"
		"Returns the unique Identifier of the Frame Burst Start type of Event.\n"
		""},
	 { "EventControl_eventFrameBurstStartTimestamp_get", _wrap_EventControl_eventFrameBurstStartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Frame Burst Start Event.\n"
		"Returns the Timestamp of the Frame Burst Start Event.\n"
		""},
	 { "EventControl_eventFrameBurstStartFrameID_get", _wrap_EventControl_eventFrameBurstStartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Burst Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Frame Burst Start Event.\n"
		""},
	 { "EventControl_eventFrameBurstEnd_get", _wrap_EventControl_eventFrameBurstEnd_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame Burst End type of Event.\n"
		"Returns the unique Identifier of the Frame Burst End type of Event.\n"
		""},
	 { "EventControl_eventFrameBurstEndTimestamp_get", _wrap_EventControl_eventFrameBurstEndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Frame Burst End Event.\n"
		"Returns the Timestamp of the Frame Burst End Event.\n"
		""},
	 { "EventControl_eventFrameBurstEndFrameID_get", _wrap_EventControl_eventFrameBurstEndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Burst End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Frame Burst End Event.\n"
		""},
	 { "EventControl_eventFrameTrigger_get", _wrap_EventControl_eventFrameTrigger_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame Trigger type of Event.\n"
		"Returns the unique Identifier of the Frame Trigger type of Event.\n"
		""},
	 { "EventControl_eventFrameTriggerTimestamp_get", _wrap_EventControl_eventFrameTriggerTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Frame Trigger Event.\n"
		"Returns the Timestamp of the Frame Trigger Event.\n"
		""},
	 { "EventControl_eventFrameTriggerFrameID_get", _wrap_EventControl_eventFrameTriggerFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Trigger Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Frame Trigger Event.\n"
		""},
	 { "EventControl_eventFrameTriggerMissed_get", _wrap_EventControl_eventFrameTriggerMissed_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame Trigger Missed type of Event.\n"
		"Returns the unique Identifier of the Frame Trigger Missed type of Event.\n"
		""},
	 { "EventControl_eventFrameTriggerMissedTimestamp_get", _wrap_EventControl_eventFrameTriggerMissedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Frame Trigger Missed Event.\n"
		"Returns the Timestamp of the Frame Trigger Missed Event.\n"
		""},
	 { "EventControl_eventFrameTriggerMissedFrameID_get", _wrap_EventControl_eventFrameTriggerMissedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Trigger Missed Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Frame Trigger Missed Event.\n"
		""},
	 { "EventControl_eventDeviceTemperatureStateNormal_get", _wrap_EventControl_eventDeviceTemperatureStateNormal_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the DeviceTemperatureState Normal type of Event.\n"
		"Returns the unique Identifier of the DeviceTemperatureState Normal type of Event.\n"
		""},
	 { "EventControl_eventDeviceTemperatureStateNormalTimestamp_get", _wrap_EventControl_eventDeviceTemperatureStateNormalTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the DeviceTemperatureState Normal Event.\n"
		"Returns the Timestamp of the DeviceTemperatureState Normal Event.\n"
		""},
	 { "EventControl_eventDeviceTemperatureStateCritical_get", _wrap_EventControl_eventDeviceTemperatureStateCritical_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the DeviceTemperatureState Critical type of Event.\n"
		"Returns the unique Identifier of the DeviceTemperatureState Critical type of Event.\n"
		""},
	 { "EventControl_eventDeviceTemperatureStateCriticalTimestamp_get", _wrap_EventControl_eventDeviceTemperatureStateCriticalTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the DeviceTemperatureState Critical Event.\n"
		"Returns the Timestamp of the DeviceTemperatureState Critical Event\n"
		""},
	 { "EventControl_eventDeviceTemperatureStateOverTemperature_get", _wrap_EventControl_eventDeviceTemperatureStateOverTemperature_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the DeviceTemperatureState OverTemperature type of Event.\n"
		"Returns the unique Identifier of the DeviceTemperatureState OverTemperature type of Event.\n"
		""},
	 { "EventControl_eventDeviceTemperatureStateOverTemperatureTimestamp_get", _wrap_EventControl_eventDeviceTemperatureStateOverTemperatureTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the DeviceTemperatureState OverTemperature Event.\n"
		"Returns the Timestamp of the DeviceTemperatureState OverTemperature Event\n"
		""},
	 { "EventControl_eventFrameStart_get", _wrap_EventControl_eventFrameStart_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame Start type of Event.\n"
		"Returns the unique Identifier of the Frame Start type of Event.\n"
		""},
	 { "EventControl_eventFrameStartTimestamp_get", _wrap_EventControl_eventFrameStartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Frame Start Event.\n"
		"Returns the Timestamp of the Frame Start Event.\n"
		""},
	 { "EventControl_eventFrameStartFrameID_get", _wrap_EventControl_eventFrameStartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Frame Start Event.\n"
		""},
	 { "EventControl_eventFrameEnd_get", _wrap_EventControl_eventFrameEnd_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame End type of Event.\n"
		"Returns the unique Identifier of the Frame End type of Event.\n"
		""},
	 { "EventControl_eventFrameEndTimestamp_get", _wrap_EventControl_eventFrameEndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Frame End Event.\n"
		"Returns the Timestamp of the Frame End Event.\n"
		""},
	 { "EventControl_eventFrameEndFrameID_get", _wrap_EventControl_eventFrameEndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Frame End Event.\n"
		""},
	 { "EventControl_eventFrameTransferStart_get", _wrap_EventControl_eventFrameTransferStart_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame Transfer Start type of Event.\n"
		"Returns the unique Identifier of the Frame Transfer Start type of Event.\n"
		""},
	 { "EventControl_eventFrameTransferStartTimestamp_get", _wrap_EventControl_eventFrameTransferStartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Frame Transfer Start Event.\n"
		"Returns the Timestamp of the Frame Transfer Start Event.\n"
		""},
	 { "EventControl_eventFrameTransferStartFrameID_get", _wrap_EventControl_eventFrameTransferStartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Transfer Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Frame Transfer Start Event.\n"
		""},
	 { "EventControl_eventFrameTransferEnd_get", _wrap_EventControl_eventFrameTransferEnd_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame Transfer End type of Event.\n"
		"Returns the unique Identifier of the Frame Transfer End type of Event.\n"
		""},
	 { "EventControl_eventFrameTransferEndTimestamp_get", _wrap_EventControl_eventFrameTransferEndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Frame Transfer End Event.\n"
		"Returns the Timestamp of the Frame Transfer End Event.\n"
		""},
	 { "EventControl_eventFrameTransferEndFrameID_get", _wrap_EventControl_eventFrameTransferEndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Transfer End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Frame Transfer End Event.\n"
		""},
	 { "EventControl_eventLineTrigger_get", _wrap_EventControl_eventLineTrigger_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line Trigger type of Event.\n"
		"Returns the unique Identifier of the Line Trigger type of Event.\n"
		""},
	 { "EventControl_eventLineTriggerTimestamp_get", _wrap_EventControl_eventLineTriggerTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line Trigger Event.\n"
		"Returns the Timestamp of the Line Trigger Event.\n"
		""},
	 { "EventControl_eventLineTriggerFrameID_get", _wrap_EventControl_eventLineTriggerFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line Trigger Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line Trigger Event.\n"
		""},
	 { "EventControl_eventLineTriggerMissed_get", _wrap_EventControl_eventLineTriggerMissed_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line Trigger Missed type of Event.\n"
		"Returns the unique Identifier of the Line Trigger Missed type of Event.\n"
		""},
	 { "EventControl_eventLineTriggerMissedTimestamp_get", _wrap_EventControl_eventLineTriggerMissedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line Trigger Missed Event.\n"
		"Returns the Timestamp of the Line Trigger Missed Event.\n"
		""},
	 { "EventControl_eventLineTriggerMissedFrameID_get", _wrap_EventControl_eventLineTriggerMissedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line Trigger Missed Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line Trigger Missed Event.\n"
		""},
	 { "EventControl_eventLineStart_get", _wrap_EventControl_eventLineStart_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line Start type of Event.\n"
		"Returns the unique Identifier of the Line Start type of Event.\n"
		""},
	 { "EventControl_eventLineStartTimestamp_get", _wrap_EventControl_eventLineStartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line Start Event.\n"
		"Returns the Timestamp of the Line Start Event.\n"
		""},
	 { "EventControl_eventLineStartFrameID_get", _wrap_EventControl_eventLineStartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line Start Event.\n"
		""},
	 { "EventControl_eventLineEnd_get", _wrap_EventControl_eventLineEnd_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line End type of Event.\n"
		"Returns the unique Identifier of the Line End type of Event.\n"
		""},
	 { "EventControl_eventLineEndTimestamp_get", _wrap_EventControl_eventLineEndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line End Event.\n"
		"Returns the Timestamp of the Line End Event.\n"
		""},
	 { "EventControl_eventLineEndFrameID_get", _wrap_EventControl_eventLineEndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line End Event.\n"
		""},
	 { "EventControl_eventExposureStart_get", _wrap_EventControl_eventExposureStart_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Exposure Start type of Event.\n"
		"Returns the unique Identifier of the Exposure Start type of Event.\n"
		""},
	 { "EventControl_eventExposureStartTimestamp_get", _wrap_EventControl_eventExposureStartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Exposure Start Event.\n"
		"Returns the Timestamp of the Exposure Start Event.\n"
		""},
	 { "EventControl_eventExposureStartFrameID_get", _wrap_EventControl_eventExposureStartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Exposure Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Exposure Start Event.\n"
		""},
	 { "EventControl_eventExposureEnd_get", _wrap_EventControl_eventExposureEnd_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Exposure End type of Event.\n"
		"Returns the unique Identifier of the Exposure End type of Event.\n"
		""},
	 { "EventControl_eventExposureEndTimestamp_get", _wrap_EventControl_eventExposureEndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Exposure End Event.\n"
		"Returns the Timestamp of the Exposure End Event.\n"
		""},
	 { "EventControl_eventExposureEndFrameID_get", _wrap_EventControl_eventExposureEndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Exposure End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Exposure End Event.\n"
		""},
	 { "EventControl_eventActionLate_get", _wrap_EventControl_eventActionLate_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Action Late type of Event.\n"
		"Returns the unique Identifier of the Action Late type of Event.\n"
		""},
	 { "EventControl_eventActionLateTimestamp_get", _wrap_EventControl_eventActionLateTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Action Late Event.\n"
		"Returns the Timestamp of the Action Late Event.\n"
		""},
	 { "EventControl_eventActionLateFrameID_get", _wrap_EventControl_eventActionLateFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Action Late Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Action Late Event.\n"
		""},
	 { "EventControl_eventPrimaryApplicationSwitch_get", _wrap_EventControl_eventPrimaryApplicationSwitch_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Primary Application Switch type of Event.\n"
		"Returns the unique Identifier of the Primary Application Switch type of Event.\n"
		""},
	 { "EventControl_eventPrimaryApplicationSwitchTimestamp_get", _wrap_EventControl_eventPrimaryApplicationSwitchTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Primary Application Switch Event.\n"
		"Returns the Timestamp of the Primary Application Switch Event.\n"
		""},
	 { "EventControl_eventPrimaryApplicationSwitchFrameID_get", _wrap_EventControl_eventPrimaryApplicationSwitchFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Primary Application Switch Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Primary Application Switch Event.\n"
		""},
	 { "EventControl_eventTest_get", _wrap_EventControl_eventTest_get, METH_O, "\n"
		"An integer property. Returns the unique identifier of the Event Test type of event generated using the TestEventGenerate command.\n"
		"Returns the unique identifier of the Event Test type of event generated using the TestEventGenerate command. It can be used to register a callback function to be notified of the EventTest event occurrence. Its value uniquely identifies that the event received was an Event Test.\n"
		""},
	 { "EventControl_eventTestTimestamp_get", _wrap_EventControl_eventTestTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Event Test event.\n"
		"Returns the Timestamp of the Event Test event. It can be used to determine when the event occurred.\n"
		""},
	 { "EventControl_eventCounter0Start_get", _wrap_EventControl_eventCounter0Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 0 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 0 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter0StartTimestamp_get", _wrap_EventControl_eventCounter0StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 0 Start Event.\n"
		"Returns the Timestamp of the Counter 0 Start Event.\n"
		""},
	 { "EventControl_eventCounter0StartFrameID_get", _wrap_EventControl_eventCounter0StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 0 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 0 Start Event.\n"
		""},
	 { "EventControl_eventCounter1Start_get", _wrap_EventControl_eventCounter1Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 1 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 1 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter1StartTimestamp_get", _wrap_EventControl_eventCounter1StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 1 Start Event.\n"
		"Returns the Timestamp of the Counter 1 Start Event.\n"
		""},
	 { "EventControl_eventCounter1StartFrameID_get", _wrap_EventControl_eventCounter1StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 1 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 1 Start Event.\n"
		""},
	 { "EventControl_eventCounter2Start_get", _wrap_EventControl_eventCounter2Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 2 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 2 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter2StartTimestamp_get", _wrap_EventControl_eventCounter2StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 2 Start Event.\n"
		"Returns the Timestamp of the Counter 2 Start Event.\n"
		""},
	 { "EventControl_eventCounter2StartFrameID_get", _wrap_EventControl_eventCounter2StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 2 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 2 Start Event.\n"
		""},
	 { "EventControl_eventCounter3Start_get", _wrap_EventControl_eventCounter3Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 3 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 3 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter3StartTimestamp_get", _wrap_EventControl_eventCounter3StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 3 Start Event.\n"
		"Returns the Timestamp of the Counter 3 Start Event.\n"
		""},
	 { "EventControl_eventCounter3StartFrameID_get", _wrap_EventControl_eventCounter3StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 3 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 3 Start Event.\n"
		""},
	 { "EventControl_eventCounter4Start_get", _wrap_EventControl_eventCounter4Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 4 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 4 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter4StartTimestamp_get", _wrap_EventControl_eventCounter4StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 4 Start Event.\n"
		"Returns the Timestamp of the Counter 4 Start Event.\n"
		""},
	 { "EventControl_eventCounter4StartFrameID_get", _wrap_EventControl_eventCounter4StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 4 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 4 Start Event.\n"
		""},
	 { "EventControl_eventCounter5Start_get", _wrap_EventControl_eventCounter5Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 5 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 5 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter5StartTimestamp_get", _wrap_EventControl_eventCounter5StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 5 Start Event.\n"
		"Returns the Timestamp of the Counter 5 Start Event.\n"
		""},
	 { "EventControl_eventCounter5StartFrameID_get", _wrap_EventControl_eventCounter5StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 5 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 5 Start Event.\n"
		""},
	 { "EventControl_eventCounter6Start_get", _wrap_EventControl_eventCounter6Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 6 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 6 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter6StartTimestamp_get", _wrap_EventControl_eventCounter6StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 6 Start Event.\n"
		"Returns the Timestamp of the Counter 6 Start Event.\n"
		""},
	 { "EventControl_eventCounter6StartFrameID_get", _wrap_EventControl_eventCounter6StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 6 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 6 Start Event.\n"
		""},
	 { "EventControl_eventCounter7Start_get", _wrap_EventControl_eventCounter7Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 7 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 7 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter7StartTimestamp_get", _wrap_EventControl_eventCounter7StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 7 Start Event.\n"
		"Returns the Timestamp of the Counter 7 Start Event.\n"
		""},
	 { "EventControl_eventCounter7StartFrameID_get", _wrap_EventControl_eventCounter7StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 7 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 7 Start Event.\n"
		""},
	 { "EventControl_eventCounter8Start_get", _wrap_EventControl_eventCounter8Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 8 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 8 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter8StartTimestamp_get", _wrap_EventControl_eventCounter8StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 8 Start Event.\n"
		"Returns the Timestamp of the Counter 8 Start Event.\n"
		""},
	 { "EventControl_eventCounter8StartFrameID_get", _wrap_EventControl_eventCounter8StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 8 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 8 Start Event.\n"
		""},
	 { "EventControl_eventCounter9Start_get", _wrap_EventControl_eventCounter9Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 9 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 9 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter9StartTimestamp_get", _wrap_EventControl_eventCounter9StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 9 Start Event.\n"
		"Returns the Timestamp of the Counter 9 Start Event.\n"
		""},
	 { "EventControl_eventCounter9StartFrameID_get", _wrap_EventControl_eventCounter9StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 9 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 9 Start Event.\n"
		""},
	 { "EventControl_eventCounter10Start_get", _wrap_EventControl_eventCounter10Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 10 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 10 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter10StartTimestamp_get", _wrap_EventControl_eventCounter10StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 10 Start Event.\n"
		"Returns the Timestamp of the Counter 10 Start Event.\n"
		""},
	 { "EventControl_eventCounter10StartFrameID_get", _wrap_EventControl_eventCounter10StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 10 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 10 Start Event.\n"
		""},
	 { "EventControl_eventCounter11Start_get", _wrap_EventControl_eventCounter11Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 11 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 11 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter11StartTimestamp_get", _wrap_EventControl_eventCounter11StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 11 Start Event.\n"
		"Returns the Timestamp of the Counter 11 Start Event.\n"
		""},
	 { "EventControl_eventCounter11StartFrameID_get", _wrap_EventControl_eventCounter11StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 11 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 11 Start Event.\n"
		""},
	 { "EventControl_eventCounter12Start_get", _wrap_EventControl_eventCounter12Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 12 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 12 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter12StartTimestamp_get", _wrap_EventControl_eventCounter12StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 12 Start Event.\n"
		"Returns the Timestamp of the Counter 12 Start Event.\n"
		""},
	 { "EventControl_eventCounter12StartFrameID_get", _wrap_EventControl_eventCounter12StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 12 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 12 Start Event.\n"
		""},
	 { "EventControl_eventCounter13Start_get", _wrap_EventControl_eventCounter13Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 13 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 13 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter13StartTimestamp_get", _wrap_EventControl_eventCounter13StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 13 Start Event.\n"
		"Returns the Timestamp of the Counter 13 Start Event.\n"
		""},
	 { "EventControl_eventCounter13StartFrameID_get", _wrap_EventControl_eventCounter13StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 13 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 13 Start Event.\n"
		""},
	 { "EventControl_eventCounter14Start_get", _wrap_EventControl_eventCounter14Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 14 Start type of Event.\n"
		"Returns the unique Identifier of the Counter 14 Start type of Event.\n"
		""},
	 { "EventControl_eventCounter14StartTimestamp_get", _wrap_EventControl_eventCounter14StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 14 Start Event.\n"
		"Returns the Timestamp of the Counter 14 Start Event.\n"
		""},
	 { "EventControl_eventCounter14StartFrameID_get", _wrap_EventControl_eventCounter14StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 14 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 14 Start Event.\n"
		""},
	 { "EventControl_eventCounter0End_get", _wrap_EventControl_eventCounter0End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 0 End type of Event.\n"
		"Returns the unique Identifier of the Counter 0 End type of Event.\n"
		""},
	 { "EventControl_eventCounter0EndTimestamp_get", _wrap_EventControl_eventCounter0EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 0 End Event.\n"
		"Returns the Timestamp of the Counter 0 End Event.\n"
		""},
	 { "EventControl_eventCounter0EndFrameID_get", _wrap_EventControl_eventCounter0EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 0 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 0 End Event.\n"
		""},
	 { "EventControl_eventCounter1End_get", _wrap_EventControl_eventCounter1End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 1 End type of Event.\n"
		"Returns the unique Identifier of the Counter 1 End type of Event.\n"
		""},
	 { "EventControl_eventCounter1EndTimestamp_get", _wrap_EventControl_eventCounter1EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 1 End Event.\n"
		"Returns the Timestamp of the Counter 1 End Event.\n"
		""},
	 { "EventControl_eventCounter1EndFrameID_get", _wrap_EventControl_eventCounter1EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 1 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 1 End Event.\n"
		""},
	 { "EventControl_eventCounter2End_get", _wrap_EventControl_eventCounter2End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 2 End type of Event.\n"
		"Returns the unique Identifier of the Counter 2 End type of Event.\n"
		""},
	 { "EventControl_eventCounter2EndTimestamp_get", _wrap_EventControl_eventCounter2EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 2 End Event.\n"
		"Returns the Timestamp of the Counter 2 End Event.\n"
		""},
	 { "EventControl_eventCounter2EndFrameID_get", _wrap_EventControl_eventCounter2EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 2 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 2 End Event.\n"
		""},
	 { "EventControl_eventCounter3End_get", _wrap_EventControl_eventCounter3End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 3 End type of Event.\n"
		"Returns the unique Identifier of the Counter 3 End type of Event.\n"
		""},
	 { "EventControl_eventCounter3EndTimestamp_get", _wrap_EventControl_eventCounter3EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 3 End Event.\n"
		"Returns the Timestamp of the Counter 3 End Event.\n"
		""},
	 { "EventControl_eventCounter3EndFrameID_get", _wrap_EventControl_eventCounter3EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 3 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 3 End Event.\n"
		""},
	 { "EventControl_eventCounter4End_get", _wrap_EventControl_eventCounter4End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 4 End type of Event.\n"
		"Returns the unique Identifier of the Counter 4 End type of Event.\n"
		""},
	 { "EventControl_eventCounter4EndTimestamp_get", _wrap_EventControl_eventCounter4EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 4 End Event.\n"
		"Returns the Timestamp of the Counter 4 End Event.\n"
		""},
	 { "EventControl_eventCounter4EndFrameID_get", _wrap_EventControl_eventCounter4EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 4 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 4 End Event.\n"
		""},
	 { "EventControl_eventCounter5End_get", _wrap_EventControl_eventCounter5End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 5 End type of Event.\n"
		"Returns the unique Identifier of the Counter 5 End type of Event.\n"
		""},
	 { "EventControl_eventCounter5EndTimestamp_get", _wrap_EventControl_eventCounter5EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 5 End Event.\n"
		"Returns the Timestamp of the Counter 5 End Event.\n"
		""},
	 { "EventControl_eventCounter5EndFrameID_get", _wrap_EventControl_eventCounter5EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 5 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 5 End Event.\n"
		""},
	 { "EventControl_eventCounter6End_get", _wrap_EventControl_eventCounter6End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 6 End type of Event.\n"
		"Returns the unique Identifier of the Counter 6 End type of Event.\n"
		""},
	 { "EventControl_eventCounter6EndTimestamp_get", _wrap_EventControl_eventCounter6EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 6 End Event.\n"
		"Returns the Timestamp of the Counter 6 End Event.\n"
		""},
	 { "EventControl_eventCounter6EndFrameID_get", _wrap_EventControl_eventCounter6EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 6 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 6 End Event.\n"
		""},
	 { "EventControl_eventCounter7End_get", _wrap_EventControl_eventCounter7End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 7 End type of Event.\n"
		"Returns the unique Identifier of the Counter 7 End type of Event.\n"
		""},
	 { "EventControl_eventCounter7EndTimestamp_get", _wrap_EventControl_eventCounter7EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 7 End Event.\n"
		"Returns the Timestamp of the Counter 7 End Event.\n"
		""},
	 { "EventControl_eventCounter7EndFrameID_get", _wrap_EventControl_eventCounter7EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 7 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 7 End Event.\n"
		""},
	 { "EventControl_eventCounter8End_get", _wrap_EventControl_eventCounter8End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 8 End type of Event.\n"
		"Returns the unique Identifier of the Counter 8 End type of Event.\n"
		""},
	 { "EventControl_eventCounter8EndTimestamp_get", _wrap_EventControl_eventCounter8EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 8 End Event.\n"
		"Returns the Timestamp of the Counter 8 End Event.\n"
		""},
	 { "EventControl_eventCounter8EndFrameID_get", _wrap_EventControl_eventCounter8EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 8 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 8 End Event.\n"
		""},
	 { "EventControl_eventCounter9End_get", _wrap_EventControl_eventCounter9End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 9 End type of Event.\n"
		"Returns the unique Identifier of the Counter 9 End type of Event.\n"
		""},
	 { "EventControl_eventCounter9EndTimestamp_get", _wrap_EventControl_eventCounter9EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 9 End Event.\n"
		"Returns the Timestamp of the Counter 9 End Event.\n"
		""},
	 { "EventControl_eventCounter9EndFrameID_get", _wrap_EventControl_eventCounter9EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 9 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 9 End Event.\n"
		""},
	 { "EventControl_eventCounter10End_get", _wrap_EventControl_eventCounter10End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 10 End type of Event.\n"
		"Returns the unique Identifier of the Counter 10 End type of Event.\n"
		""},
	 { "EventControl_eventCounter10EndTimestamp_get", _wrap_EventControl_eventCounter10EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 10 End Event.\n"
		"Returns the Timestamp of the Counter 10 End Event.\n"
		""},
	 { "EventControl_eventCounter10EndFrameID_get", _wrap_EventControl_eventCounter10EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 10 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 10 End Event.\n"
		""},
	 { "EventControl_eventCounter11End_get", _wrap_EventControl_eventCounter11End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 11 End type of Event.\n"
		"Returns the unique Identifier of the Counter 11 End type of Event.\n"
		""},
	 { "EventControl_eventCounter11EndTimestamp_get", _wrap_EventControl_eventCounter11EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 11 End Event.\n"
		"Returns the Timestamp of the Counter 11 End Event.\n"
		""},
	 { "EventControl_eventCounter11EndFrameID_get", _wrap_EventControl_eventCounter11EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 11 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 11 End Event.\n"
		""},
	 { "EventControl_eventCounter12End_get", _wrap_EventControl_eventCounter12End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 12 End type of Event.\n"
		"Returns the unique Identifier of the Counter 12 End type of Event.\n"
		""},
	 { "EventControl_eventCounter12EndTimestamp_get", _wrap_EventControl_eventCounter12EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 12 End Event.\n"
		"Returns the Timestamp of the Counter 12 End Event.\n"
		""},
	 { "EventControl_eventCounter12EndFrameID_get", _wrap_EventControl_eventCounter12EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 12 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 12 End Event.\n"
		""},
	 { "EventControl_eventCounter13End_get", _wrap_EventControl_eventCounter13End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 13 End type of Event.\n"
		"Returns the unique Identifier of the Counter 13 End type of Event.\n"
		""},
	 { "EventControl_eventCounter13EndTimestamp_get", _wrap_EventControl_eventCounter13EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 13 End Event.\n"
		"Returns the Timestamp of the Counter 13 End Event.\n"
		""},
	 { "EventControl_eventCounter13EndFrameID_get", _wrap_EventControl_eventCounter13EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 13 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 13 End Event.\n"
		""},
	 { "EventControl_eventCounter14End_get", _wrap_EventControl_eventCounter14End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Counter 14 End type of Event.\n"
		"Returns the unique Identifier of the Counter 14 End type of Event.\n"
		""},
	 { "EventControl_eventCounter14EndTimestamp_get", _wrap_EventControl_eventCounter14EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Counter 14 End Event.\n"
		"Returns the Timestamp of the Counter 14 End Event.\n"
		""},
	 { "EventControl_eventCounter14EndFrameID_get", _wrap_EventControl_eventCounter14EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 14 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Counter 14 End Event.\n"
		""},
	 { "EventControl_eventTimer0Start_get", _wrap_EventControl_eventTimer0Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 0 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 0 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer0StartTimestamp_get", _wrap_EventControl_eventTimer0StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 0 Start Event.\n"
		"Returns the Timestamp of the Timer 0 Start Event.\n"
		""},
	 { "EventControl_eventTimer0StartFrameID_get", _wrap_EventControl_eventTimer0StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 0 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 0 Start Event.\n"
		""},
	 { "EventControl_eventTimer1Start_get", _wrap_EventControl_eventTimer1Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 1 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 1 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer1StartTimestamp_get", _wrap_EventControl_eventTimer1StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 1 Start Event.\n"
		"Returns the Timestamp of the Timer 1 Start Event.\n"
		""},
	 { "EventControl_eventTimer1StartFrameID_get", _wrap_EventControl_eventTimer1StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 1 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 1 Start Event.\n"
		""},
	 { "EventControl_eventTimer2Start_get", _wrap_EventControl_eventTimer2Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 2 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 2 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer2StartTimestamp_get", _wrap_EventControl_eventTimer2StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 2 Start Event.\n"
		"Returns the Timestamp of the Timer 2 Start Event.\n"
		""},
	 { "EventControl_eventTimer2StartFrameID_get", _wrap_EventControl_eventTimer2StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 2 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 2 Start Event.\n"
		""},
	 { "EventControl_eventTimer3Start_get", _wrap_EventControl_eventTimer3Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 3 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 3 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer3StartTimestamp_get", _wrap_EventControl_eventTimer3StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 3 Start Event.\n"
		"Returns the Timestamp of the Timer 3 Start Event.\n"
		""},
	 { "EventControl_eventTimer3StartFrameID_get", _wrap_EventControl_eventTimer3StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 3 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 3 Start Event.\n"
		""},
	 { "EventControl_eventTimer4Start_get", _wrap_EventControl_eventTimer4Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 4 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 4 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer4StartTimestamp_get", _wrap_EventControl_eventTimer4StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 4 Start Event.\n"
		"Returns the Timestamp of the Timer 4 Start Event.\n"
		""},
	 { "EventControl_eventTimer4StartFrameID_get", _wrap_EventControl_eventTimer4StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 4 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 4 Start Event.\n"
		""},
	 { "EventControl_eventTimer5Start_get", _wrap_EventControl_eventTimer5Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 5 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 5 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer5StartTimestamp_get", _wrap_EventControl_eventTimer5StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 5 Start Event.\n"
		"Returns the Timestamp of the Timer 5 Start Event.\n"
		""},
	 { "EventControl_eventTimer5StartFrameID_get", _wrap_EventControl_eventTimer5StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 5 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 5 Start Event.\n"
		""},
	 { "EventControl_eventTimer6Start_get", _wrap_EventControl_eventTimer6Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 6 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 6 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer6StartTimestamp_get", _wrap_EventControl_eventTimer6StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 6 Start Event.\n"
		"Returns the Timestamp of the Timer 6 Start Event.\n"
		""},
	 { "EventControl_eventTimer6StartFrameID_get", _wrap_EventControl_eventTimer6StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 6 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 6 Start Event.\n"
		""},
	 { "EventControl_eventTimer7Start_get", _wrap_EventControl_eventTimer7Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 7 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 7 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer7StartTimestamp_get", _wrap_EventControl_eventTimer7StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 7 Start Event.\n"
		"Returns the Timestamp of the Timer 7 Start Event.\n"
		""},
	 { "EventControl_eventTimer7StartFrameID_get", _wrap_EventControl_eventTimer7StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 7 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 7 Start Event.\n"
		""},
	 { "EventControl_eventTimer8Start_get", _wrap_EventControl_eventTimer8Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 8 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 8 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer8StartTimestamp_get", _wrap_EventControl_eventTimer8StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 8 Start Event.\n"
		"Returns the Timestamp of the Timer 8 Start Event.\n"
		""},
	 { "EventControl_eventTimer8StartFrameID_get", _wrap_EventControl_eventTimer8StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 8 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 8 Start Event.\n"
		""},
	 { "EventControl_eventTimer9Start_get", _wrap_EventControl_eventTimer9Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 9 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 9 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer9StartTimestamp_get", _wrap_EventControl_eventTimer9StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 9 Start Event.\n"
		"Returns the Timestamp of the Timer 9 Start Event.\n"
		""},
	 { "EventControl_eventTimer9StartFrameID_get", _wrap_EventControl_eventTimer9StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 9 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 9 Start Event.\n"
		""},
	 { "EventControl_eventTimer10Start_get", _wrap_EventControl_eventTimer10Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 10 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 10 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer10StartTimestamp_get", _wrap_EventControl_eventTimer10StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 10 Start Event.\n"
		"Returns the Timestamp of the Timer 10 Start Event.\n"
		""},
	 { "EventControl_eventTimer10StartFrameID_get", _wrap_EventControl_eventTimer10StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 10 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 10 Start Event.\n"
		""},
	 { "EventControl_eventTimer11Start_get", _wrap_EventControl_eventTimer11Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 11 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 11 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer11StartTimestamp_get", _wrap_EventControl_eventTimer11StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 11 Start Event.\n"
		"Returns the Timestamp of the Timer 11 Start Event.\n"
		""},
	 { "EventControl_eventTimer11StartFrameID_get", _wrap_EventControl_eventTimer11StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 11 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 11 Start Event.\n"
		""},
	 { "EventControl_eventTimer12Start_get", _wrap_EventControl_eventTimer12Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 12 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 12 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer12StartTimestamp_get", _wrap_EventControl_eventTimer12StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 12 Start Event.\n"
		"Returns the Timestamp of the Timer 12 Start Event.\n"
		""},
	 { "EventControl_eventTimer12StartFrameID_get", _wrap_EventControl_eventTimer12StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 12 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 12 Start Event.\n"
		""},
	 { "EventControl_eventTimer13Start_get", _wrap_EventControl_eventTimer13Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 13 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 13 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer13StartTimestamp_get", _wrap_EventControl_eventTimer13StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 13 Start Event.\n"
		"Returns the Timestamp of the Timer 13 Start Event.\n"
		""},
	 { "EventControl_eventTimer13StartFrameID_get", _wrap_EventControl_eventTimer13StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 13 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 13 Start Event.\n"
		""},
	 { "EventControl_eventTimer14Start_get", _wrap_EventControl_eventTimer14Start_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 14 Start type of Event.\n"
		"Returns the unique Identifier of the Timer 14 Start type of Event.\n"
		""},
	 { "EventControl_eventTimer14StartTimestamp_get", _wrap_EventControl_eventTimer14StartTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 14 Start Event.\n"
		"Returns the Timestamp of the Timer 14 Start Event.\n"
		""},
	 { "EventControl_eventTimer14StartFrameID_get", _wrap_EventControl_eventTimer14StartFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 14 Start Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 14 Start Event.\n"
		""},
	 { "EventControl_eventTimer0End_get", _wrap_EventControl_eventTimer0End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 0 End type of Event.\n"
		"Returns the unique Identifier of the Timer 0 End type of Event.\n"
		""},
	 { "EventControl_eventTimer0EndTimestamp_get", _wrap_EventControl_eventTimer0EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 0 End Event.\n"
		"Returns the Timestamp of the Timer 0 End Event.\n"
		""},
	 { "EventControl_eventTimer0EndFrameID_get", _wrap_EventControl_eventTimer0EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 0 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 0 End Event.\n"
		""},
	 { "EventControl_eventTimer1End_get", _wrap_EventControl_eventTimer1End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 1 End type of Event.\n"
		"Returns the unique Identifier of the Timer 1 End type of Event.\n"
		""},
	 { "EventControl_eventTimer1EndTimestamp_get", _wrap_EventControl_eventTimer1EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 1 End Event.\n"
		"Returns the Timestamp of the Timer 1 End Event.\n"
		""},
	 { "EventControl_eventTimer1EndFrameID_get", _wrap_EventControl_eventTimer1EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 1 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 1 End Event.\n"
		""},
	 { "EventControl_eventTimer2End_get", _wrap_EventControl_eventTimer2End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 2 End type of Event.\n"
		"Returns the unique Identifier of the Timer 2 End type of Event.\n"
		""},
	 { "EventControl_eventTimer2EndTimestamp_get", _wrap_EventControl_eventTimer2EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 2 End Event.\n"
		"Returns the Timestamp of the Timer 2 End Event.\n"
		""},
	 { "EventControl_eventTimer2EndFrameID_get", _wrap_EventControl_eventTimer2EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 2 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 2 End Event.\n"
		""},
	 { "EventControl_eventTimer3End_get", _wrap_EventControl_eventTimer3End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 3 End type of Event.\n"
		"Returns the unique Identifier of the Timer 3 End type of Event.\n"
		""},
	 { "EventControl_eventTimer3EndTimestamp_get", _wrap_EventControl_eventTimer3EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 3 End Event.\n"
		"Returns the Timestamp of the Timer 3 End Event.\n"
		""},
	 { "EventControl_eventTimer3EndFrameID_get", _wrap_EventControl_eventTimer3EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 3 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 3 End Event.\n"
		""},
	 { "EventControl_eventTimer4End_get", _wrap_EventControl_eventTimer4End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 4 End type of Event.\n"
		"Returns the unique Identifier of the Timer 4 End type of Event.\n"
		""},
	 { "EventControl_eventTimer4EndTimestamp_get", _wrap_EventControl_eventTimer4EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 4 End Event.\n"
		"Returns the Timestamp of the Timer 4 End Event.\n"
		""},
	 { "EventControl_eventTimer4EndFrameID_get", _wrap_EventControl_eventTimer4EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 4 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 4 End Event.\n"
		""},
	 { "EventControl_eventTimer5End_get", _wrap_EventControl_eventTimer5End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 5 End type of Event.\n"
		"Returns the unique Identifier of the Timer 5 End type of Event.\n"
		""},
	 { "EventControl_eventTimer5EndTimestamp_get", _wrap_EventControl_eventTimer5EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 5 End Event.\n"
		"Returns the Timestamp of the Timer 5 End Event.\n"
		""},
	 { "EventControl_eventTimer5EndFrameID_get", _wrap_EventControl_eventTimer5EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 5 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 5 End Event.\n"
		""},
	 { "EventControl_eventTimer6End_get", _wrap_EventControl_eventTimer6End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 6 End type of Event.\n"
		"Returns the unique Identifier of the Timer 6 End type of Event.\n"
		""},
	 { "EventControl_eventTimer6EndTimestamp_get", _wrap_EventControl_eventTimer6EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 6 End Event.\n"
		"Returns the Timestamp of the Timer 6 End Event.\n"
		""},
	 { "EventControl_eventTimer6EndFrameID_get", _wrap_EventControl_eventTimer6EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 6 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 6 End Event.\n"
		""},
	 { "EventControl_eventTimer7End_get", _wrap_EventControl_eventTimer7End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 7 End type of Event.\n"
		"Returns the unique Identifier of the Timer 7 End type of Event.\n"
		""},
	 { "EventControl_eventTimer7EndTimestamp_get", _wrap_EventControl_eventTimer7EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 7 End Event.\n"
		"Returns the Timestamp of the Timer 7 End Event.\n"
		""},
	 { "EventControl_eventTimer7EndFrameID_get", _wrap_EventControl_eventTimer7EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 7 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 7 End Event.\n"
		""},
	 { "EventControl_eventTimer8End_get", _wrap_EventControl_eventTimer8End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 8 End type of Event.\n"
		"Returns the unique Identifier of the Timer 8 End type of Event.\n"
		""},
	 { "EventControl_eventTimer8EndTimestamp_get", _wrap_EventControl_eventTimer8EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 8 End Event.\n"
		"Returns the Timestamp of the Timer 8 End Event.\n"
		""},
	 { "EventControl_eventTimer8EndFrameID_get", _wrap_EventControl_eventTimer8EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 8 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 8 End Event.\n"
		""},
	 { "EventControl_eventTimer9End_get", _wrap_EventControl_eventTimer9End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 9 End type of Event.\n"
		"Returns the unique Identifier of the Timer 9 End type of Event.\n"
		""},
	 { "EventControl_eventTimer9EndTimestamp_get", _wrap_EventControl_eventTimer9EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 9 End Event.\n"
		"Returns the Timestamp of the Timer 9 End Event.\n"
		""},
	 { "EventControl_eventTimer9EndFrameID_get", _wrap_EventControl_eventTimer9EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 9 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 9 End Event.\n"
		""},
	 { "EventControl_eventTimer10End_get", _wrap_EventControl_eventTimer10End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 10 End type of Event.\n"
		"Returns the unique Identifier of the Timer 10 End type of Event.\n"
		""},
	 { "EventControl_eventTimer10EndTimestamp_get", _wrap_EventControl_eventTimer10EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 10 End Event.\n"
		"Returns the Timestamp of the Timer 10 End Event.\n"
		""},
	 { "EventControl_eventTimer10EndFrameID_get", _wrap_EventControl_eventTimer10EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 10 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 10 End Event.\n"
		""},
	 { "EventControl_eventTimer11End_get", _wrap_EventControl_eventTimer11End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 11 End type of Event.\n"
		"Returns the unique Identifier of the Timer 11 End type of Event.\n"
		""},
	 { "EventControl_eventTimer11EndTimestamp_get", _wrap_EventControl_eventTimer11EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 11 End Event.\n"
		"Returns the Timestamp of the Timer 11 End Event.\n"
		""},
	 { "EventControl_eventTimer11EndFrameID_get", _wrap_EventControl_eventTimer11EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 11 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 11 End Event.\n"
		""},
	 { "EventControl_eventTimer12End_get", _wrap_EventControl_eventTimer12End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 12 End type of Event.\n"
		"Returns the unique Identifier of the Timer 12 End type of Event.\n"
		""},
	 { "EventControl_eventTimer12EndTimestamp_get", _wrap_EventControl_eventTimer12EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 12 End Event.\n"
		"Returns the Timestamp of the Timer 12 End Event.\n"
		""},
	 { "EventControl_eventTimer12EndFrameID_get", _wrap_EventControl_eventTimer12EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 12 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 12 End Event.\n"
		""},
	 { "EventControl_eventTimer13End_get", _wrap_EventControl_eventTimer13End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 13 End type of Event.\n"
		"Returns the unique Identifier of the Timer 13 End type of Event.\n"
		""},
	 { "EventControl_eventTimer13EndTimestamp_get", _wrap_EventControl_eventTimer13EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 13 End Event.\n"
		"Returns the Timestamp of the Timer 13 End Event.\n"
		""},
	 { "EventControl_eventTimer13EndFrameID_get", _wrap_EventControl_eventTimer13EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 13 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 13 End Event.\n"
		""},
	 { "EventControl_eventTimer14End_get", _wrap_EventControl_eventTimer14End_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Timer 14 End type of Event.\n"
		"Returns the unique Identifier of the Timer 14 End type of Event.\n"
		""},
	 { "EventControl_eventTimer14EndTimestamp_get", _wrap_EventControl_eventTimer14EndTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Timer 14 End Event.\n"
		"Returns the Timestamp of the Timer 14 End Event.\n"
		""},
	 { "EventControl_eventTimer14EndFrameID_get", _wrap_EventControl_eventTimer14EndFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 14 End Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Timer 14 End Event.\n"
		""},
	 { "EventControl_eventEncoder0Stopped_get", _wrap_EventControl_eventEncoder0Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 0 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 0 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder0StoppedTimestamp_get", _wrap_EventControl_eventEncoder0StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 0 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 0 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder0StoppedFrameID_get", _wrap_EventControl_eventEncoder0StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 0 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 0 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder1Stopped_get", _wrap_EventControl_eventEncoder1Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 1 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 1 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder1StoppedTimestamp_get", _wrap_EventControl_eventEncoder1StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 1 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 1 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder1StoppedFrameID_get", _wrap_EventControl_eventEncoder1StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 1 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 1 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder2Stopped_get", _wrap_EventControl_eventEncoder2Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 2 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 2 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder2StoppedTimestamp_get", _wrap_EventControl_eventEncoder2StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 2 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 2 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder2StoppedFrameID_get", _wrap_EventControl_eventEncoder2StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 2 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 2 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder3Stopped_get", _wrap_EventControl_eventEncoder3Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 3 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 3 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder3StoppedTimestamp_get", _wrap_EventControl_eventEncoder3StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 3 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 3 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder3StoppedFrameID_get", _wrap_EventControl_eventEncoder3StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 3 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 3 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder4Stopped_get", _wrap_EventControl_eventEncoder4Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 4 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 4 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder4StoppedTimestamp_get", _wrap_EventControl_eventEncoder4StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 4 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 4 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder4StoppedFrameID_get", _wrap_EventControl_eventEncoder4StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 4 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 4 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder5Stopped_get", _wrap_EventControl_eventEncoder5Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 5 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 5 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder5StoppedTimestamp_get", _wrap_EventControl_eventEncoder5StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 5 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 5 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder5StoppedFrameID_get", _wrap_EventControl_eventEncoder5StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 5 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 5 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder6Stopped_get", _wrap_EventControl_eventEncoder6Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 6 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 6 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder6StoppedTimestamp_get", _wrap_EventControl_eventEncoder6StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 6 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 6 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder6StoppedFrameID_get", _wrap_EventControl_eventEncoder6StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 6 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 6 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder7Stopped_get", _wrap_EventControl_eventEncoder7Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 7 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 7 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder7StoppedTimestamp_get", _wrap_EventControl_eventEncoder7StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 7 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 7 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder7StoppedFrameID_get", _wrap_EventControl_eventEncoder7StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 7 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 7 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder8Stopped_get", _wrap_EventControl_eventEncoder8Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 8 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 8 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder8StoppedTimestamp_get", _wrap_EventControl_eventEncoder8StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 8 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 8 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder8StoppedFrameID_get", _wrap_EventControl_eventEncoder8StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 8 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 8 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder9Stopped_get", _wrap_EventControl_eventEncoder9Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 9 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 9 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder9StoppedTimestamp_get", _wrap_EventControl_eventEncoder9StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 9 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 9 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder9StoppedFrameID_get", _wrap_EventControl_eventEncoder9StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 9 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 9 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder10Stopped_get", _wrap_EventControl_eventEncoder10Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 10 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 10 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder10StoppedTimestamp_get", _wrap_EventControl_eventEncoder10StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 10 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 10 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder10StoppedFrameID_get", _wrap_EventControl_eventEncoder10StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 10 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 10 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder11Stopped_get", _wrap_EventControl_eventEncoder11Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 11 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 11 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder11StoppedTimestamp_get", _wrap_EventControl_eventEncoder11StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 11 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 11 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder11StoppedFrameID_get", _wrap_EventControl_eventEncoder11StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 11 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 11 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder12Stopped_get", _wrap_EventControl_eventEncoder12Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 12 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 12 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder12StoppedTimestamp_get", _wrap_EventControl_eventEncoder12StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 12 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 12 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder12StoppedFrameID_get", _wrap_EventControl_eventEncoder12StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 12 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 12 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder13Stopped_get", _wrap_EventControl_eventEncoder13Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 13 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 13 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder13StoppedTimestamp_get", _wrap_EventControl_eventEncoder13StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 13 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 13 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder13StoppedFrameID_get", _wrap_EventControl_eventEncoder13StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 13 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 13 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder14Stopped_get", _wrap_EventControl_eventEncoder14Stopped_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 14 Stopped type of Event.\n"
		"Returns the unique Identifier of the Encoder 14 Stopped type of Event.\n"
		""},
	 { "EventControl_eventEncoder14StoppedTimestamp_get", _wrap_EventControl_eventEncoder14StoppedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 14 Stopped Event.\n"
		"Returns the Timestamp of the Encoder 14 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder14StoppedFrameID_get", _wrap_EventControl_eventEncoder14StoppedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 14 Stopped Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 14 Stopped Event.\n"
		""},
	 { "EventControl_eventEncoder0Restarted_get", _wrap_EventControl_eventEncoder0Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 0 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 0 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder0RestartedTimestamp_get", _wrap_EventControl_eventEncoder0RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 0 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 0 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder0RestartedFrameID_get", _wrap_EventControl_eventEncoder0RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 0 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 0 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder1Restarted_get", _wrap_EventControl_eventEncoder1Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 1 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 1 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder1RestartedTimestamp_get", _wrap_EventControl_eventEncoder1RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 1 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 1 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder1RestartedFrameID_get", _wrap_EventControl_eventEncoder1RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 1 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 1 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder2Restarted_get", _wrap_EventControl_eventEncoder2Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 2 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 2 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder2RestartedTimestamp_get", _wrap_EventControl_eventEncoder2RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 2 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 2 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder2RestartedFrameID_get", _wrap_EventControl_eventEncoder2RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 2 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 2 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder3Restarted_get", _wrap_EventControl_eventEncoder3Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 3 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 3 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder3RestartedTimestamp_get", _wrap_EventControl_eventEncoder3RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 3 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 3 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder3RestartedFrameID_get", _wrap_EventControl_eventEncoder3RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 3 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 3 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder4Restarted_get", _wrap_EventControl_eventEncoder4Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 4 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 4 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder4RestartedTimestamp_get", _wrap_EventControl_eventEncoder4RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 4 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 4 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder4RestartedFrameID_get", _wrap_EventControl_eventEncoder4RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 4 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 4 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder5Restarted_get", _wrap_EventControl_eventEncoder5Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 5 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 5 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder5RestartedTimestamp_get", _wrap_EventControl_eventEncoder5RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 5 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 5 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder5RestartedFrameID_get", _wrap_EventControl_eventEncoder5RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 5 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 5 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder6Restarted_get", _wrap_EventControl_eventEncoder6Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 6 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 6 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder6RestartedTimestamp_get", _wrap_EventControl_eventEncoder6RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 6 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 6 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder6RestartedFrameID_get", _wrap_EventControl_eventEncoder6RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 6 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 6 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder7Restarted_get", _wrap_EventControl_eventEncoder7Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 7 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 7 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder7RestartedTimestamp_get", _wrap_EventControl_eventEncoder7RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 7 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 7 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder7RestartedFrameID_get", _wrap_EventControl_eventEncoder7RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 7 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 7 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder8Restarted_get", _wrap_EventControl_eventEncoder8Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 8 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 8 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder8RestartedTimestamp_get", _wrap_EventControl_eventEncoder8RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 8 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 8 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder8RestartedFrameID_get", _wrap_EventControl_eventEncoder8RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 8 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 8 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder9Restarted_get", _wrap_EventControl_eventEncoder9Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 9 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 9 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder9RestartedTimestamp_get", _wrap_EventControl_eventEncoder9RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 9 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 9 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder9RestartedFrameID_get", _wrap_EventControl_eventEncoder9RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 9 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 9 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder10Restarted_get", _wrap_EventControl_eventEncoder10Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 10 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 10 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder10RestartedTimestamp_get", _wrap_EventControl_eventEncoder10RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 10 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 10 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder10RestartedFrameID_get", _wrap_EventControl_eventEncoder10RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 10 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 10 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder11Restarted_get", _wrap_EventControl_eventEncoder11Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 11 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 11 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder11RestartedTimestamp_get", _wrap_EventControl_eventEncoder11RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 11 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 11 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder11RestartedFrameID_get", _wrap_EventControl_eventEncoder11RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 11 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 11 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder12Restarted_get", _wrap_EventControl_eventEncoder12Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 12 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 12 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder12RestartedTimestamp_get", _wrap_EventControl_eventEncoder12RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 12 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 12 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder12RestartedFrameID_get", _wrap_EventControl_eventEncoder12RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 12 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 12 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder13Restarted_get", _wrap_EventControl_eventEncoder13Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 13 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 13 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder13RestartedTimestamp_get", _wrap_EventControl_eventEncoder13RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 13 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 13 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder13RestartedFrameID_get", _wrap_EventControl_eventEncoder13RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 13 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 13 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder14Restarted_get", _wrap_EventControl_eventEncoder14Restarted_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Encoder 14 Restarted type of Event.\n"
		"Returns the unique Identifier of the Encoder 14 Restarted type of Event.\n"
		""},
	 { "EventControl_eventEncoder14RestartedTimestamp_get", _wrap_EventControl_eventEncoder14RestartedTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Encoder 14 Restarted Event.\n"
		"Returns the Timestamp of the Encoder 14 Restarted Event.\n"
		""},
	 { "EventControl_eventEncoder14RestartedFrameID_get", _wrap_EventControl_eventEncoder14RestartedFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 14 Restarted Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Encoder 14 Restarted Event.\n"
		""},
	 { "EventControl_eventLine0RisingEdge_get", _wrap_EventControl_eventLine0RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 0 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 0 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine0RisingEdgeTimestamp_get", _wrap_EventControl_eventLine0RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 0 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 0 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine0RisingEdgeFrameID_get", _wrap_EventControl_eventLine0RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 0 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 0 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine1RisingEdge_get", _wrap_EventControl_eventLine1RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 1 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 1 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine1RisingEdgeTimestamp_get", _wrap_EventControl_eventLine1RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 1 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 1 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine1RisingEdgeFrameID_get", _wrap_EventControl_eventLine1RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 1 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 1 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine2RisingEdge_get", _wrap_EventControl_eventLine2RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 2 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 2 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine2RisingEdgeTimestamp_get", _wrap_EventControl_eventLine2RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 2 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 2 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine2RisingEdgeFrameID_get", _wrap_EventControl_eventLine2RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 2 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 2 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine3RisingEdge_get", _wrap_EventControl_eventLine3RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 3 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 3 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine3RisingEdgeTimestamp_get", _wrap_EventControl_eventLine3RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 3 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 3 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine3RisingEdgeFrameID_get", _wrap_EventControl_eventLine3RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 3 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 3 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine4RisingEdge_get", _wrap_EventControl_eventLine4RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 4 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 4 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine4RisingEdgeTimestamp_get", _wrap_EventControl_eventLine4RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 4 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 4 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine4RisingEdgeFrameID_get", _wrap_EventControl_eventLine4RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 4 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 4 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine5RisingEdge_get", _wrap_EventControl_eventLine5RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 5 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 5 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine5RisingEdgeTimestamp_get", _wrap_EventControl_eventLine5RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 5 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 5 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine5RisingEdgeFrameID_get", _wrap_EventControl_eventLine5RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 5 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 5 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine6RisingEdge_get", _wrap_EventControl_eventLine6RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 6 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 6 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine6RisingEdgeTimestamp_get", _wrap_EventControl_eventLine6RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 6 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 6 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine6RisingEdgeFrameID_get", _wrap_EventControl_eventLine6RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 6 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 6 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine7RisingEdge_get", _wrap_EventControl_eventLine7RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 7 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 7 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine7RisingEdgeTimestamp_get", _wrap_EventControl_eventLine7RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 7 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 7 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine7RisingEdgeFrameID_get", _wrap_EventControl_eventLine7RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 7 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 7 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine8RisingEdge_get", _wrap_EventControl_eventLine8RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 8 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 8 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine8RisingEdgeTimestamp_get", _wrap_EventControl_eventLine8RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 8 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 8 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine8RisingEdgeFrameID_get", _wrap_EventControl_eventLine8RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 8 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 8 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine9RisingEdge_get", _wrap_EventControl_eventLine9RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 9 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 9 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine9RisingEdgeTimestamp_get", _wrap_EventControl_eventLine9RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 9 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 9 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine9RisingEdgeFrameID_get", _wrap_EventControl_eventLine9RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 9 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 9 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine10RisingEdge_get", _wrap_EventControl_eventLine10RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 10 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 10 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine10RisingEdgeTimestamp_get", _wrap_EventControl_eventLine10RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 10 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 10 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine10RisingEdgeFrameID_get", _wrap_EventControl_eventLine10RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 10 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 10 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine11RisingEdge_get", _wrap_EventControl_eventLine11RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 11 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 11 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine11RisingEdgeTimestamp_get", _wrap_EventControl_eventLine11RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 11 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 11 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine11RisingEdgeFrameID_get", _wrap_EventControl_eventLine11RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 11 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 11 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine12RisingEdge_get", _wrap_EventControl_eventLine12RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 12 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 12 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine12RisingEdgeTimestamp_get", _wrap_EventControl_eventLine12RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 12 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 12 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine12RisingEdgeFrameID_get", _wrap_EventControl_eventLine12RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 12 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 12 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine13RisingEdge_get", _wrap_EventControl_eventLine13RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 13 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 13 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine13RisingEdgeTimestamp_get", _wrap_EventControl_eventLine13RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 13 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 13 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine13RisingEdgeFrameID_get", _wrap_EventControl_eventLine13RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 13 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 13 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine14RisingEdge_get", _wrap_EventControl_eventLine14RisingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 14 Rising Edge type of Event.\n"
		"Returns the unique Identifier of the Line 14 Rising Edge type of Event.\n"
		""},
	 { "EventControl_eventLine14RisingEdgeTimestamp_get", _wrap_EventControl_eventLine14RisingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 14 Rising Edge Event.\n"
		"Returns the Timestamp of the Line 14 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine14RisingEdgeFrameID_get", _wrap_EventControl_eventLine14RisingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 14 Rising Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 14 Rising Edge Event.\n"
		""},
	 { "EventControl_eventLine0FallingEdge_get", _wrap_EventControl_eventLine0FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 0 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 0 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine0FallingEdgeTimestamp_get", _wrap_EventControl_eventLine0FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 0 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 0 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine0FallingEdgeFrameID_get", _wrap_EventControl_eventLine0FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 0 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 0 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine1FallingEdge_get", _wrap_EventControl_eventLine1FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 1 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 1 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine1FallingEdgeTimestamp_get", _wrap_EventControl_eventLine1FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 1 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 1 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine1FallingEdgeFrameID_get", _wrap_EventControl_eventLine1FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 1 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 1 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine2FallingEdge_get", _wrap_EventControl_eventLine2FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 2 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 2 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine2FallingEdgeTimestamp_get", _wrap_EventControl_eventLine2FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 2 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 2 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine2FallingEdgeFrameID_get", _wrap_EventControl_eventLine2FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 2 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 2 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine3FallingEdge_get", _wrap_EventControl_eventLine3FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 3 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 3 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine3FallingEdgeTimestamp_get", _wrap_EventControl_eventLine3FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 3 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 3 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine3FallingEdgeFrameID_get", _wrap_EventControl_eventLine3FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 3 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 3 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine4FallingEdge_get", _wrap_EventControl_eventLine4FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 4 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 4 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine4FallingEdgeTimestamp_get", _wrap_EventControl_eventLine4FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 4 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 4 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine4FallingEdgeFrameID_get", _wrap_EventControl_eventLine4FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 4 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 4 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine5FallingEdge_get", _wrap_EventControl_eventLine5FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 5 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 5 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine5FallingEdgeTimestamp_get", _wrap_EventControl_eventLine5FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 5 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 5 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine5FallingEdgeFrameID_get", _wrap_EventControl_eventLine5FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 5 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 5 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine6FallingEdge_get", _wrap_EventControl_eventLine6FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 6 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 6 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine6FallingEdgeTimestamp_get", _wrap_EventControl_eventLine6FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 6 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 6 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine6FallingEdgeFrameID_get", _wrap_EventControl_eventLine6FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 6 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 6 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine7FallingEdge_get", _wrap_EventControl_eventLine7FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 7 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 7 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine7FallingEdgeTimestamp_get", _wrap_EventControl_eventLine7FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 7 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 7 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine7FallingEdgeFrameID_get", _wrap_EventControl_eventLine7FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 7 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 7 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine8FallingEdge_get", _wrap_EventControl_eventLine8FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 8 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 8 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine8FallingEdgeTimestamp_get", _wrap_EventControl_eventLine8FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 8 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 8 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine8FallingEdgeFrameID_get", _wrap_EventControl_eventLine8FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 8 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 8 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine9FallingEdge_get", _wrap_EventControl_eventLine9FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 9 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 9 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine9FallingEdgeTimestamp_get", _wrap_EventControl_eventLine9FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 9 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 9 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine9FallingEdgeFrameID_get", _wrap_EventControl_eventLine9FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 9 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 9 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine10FallingEdge_get", _wrap_EventControl_eventLine10FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 10 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 10 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine10FallingEdgeTimestamp_get", _wrap_EventControl_eventLine10FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 10 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 10 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine10FallingEdgeFrameID_get", _wrap_EventControl_eventLine10FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 10 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 10 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine11FallingEdge_get", _wrap_EventControl_eventLine11FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 11 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 11 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine11FallingEdgeTimestamp_get", _wrap_EventControl_eventLine11FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 11 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 11 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine11FallingEdgeFrameID_get", _wrap_EventControl_eventLine11FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 11 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 11 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine12FallingEdge_get", _wrap_EventControl_eventLine12FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 12 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 12 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine12FallingEdgeTimestamp_get", _wrap_EventControl_eventLine12FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 12 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 12 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine12FallingEdgeFrameID_get", _wrap_EventControl_eventLine12FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 12 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 12 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine13FallingEdge_get", _wrap_EventControl_eventLine13FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 13 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 13 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine13FallingEdgeTimestamp_get", _wrap_EventControl_eventLine13FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 13 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 13 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine13FallingEdgeFrameID_get", _wrap_EventControl_eventLine13FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 13 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 13 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine14FallingEdge_get", _wrap_EventControl_eventLine14FallingEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 14 Falling Edge type of Event.\n"
		"Returns the unique Identifier of the Line 14 Falling Edge type of Event.\n"
		""},
	 { "EventControl_eventLine14FallingEdgeTimestamp_get", _wrap_EventControl_eventLine14FallingEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 14 Falling Edge Event.\n"
		"Returns the Timestamp of the Line 14 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine14FallingEdgeFrameID_get", _wrap_EventControl_eventLine14FallingEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 14 Falling Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 14 Falling Edge Event.\n"
		""},
	 { "EventControl_eventLine0AnyEdge_get", _wrap_EventControl_eventLine0AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 0 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 0 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine0AnyEdgeTimestamp_get", _wrap_EventControl_eventLine0AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 0 Any Edge Event.\n"
		"Returns the Timestamp of the Line 0 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine0AnyEdgeFrameID_get", _wrap_EventControl_eventLine0AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 0 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 0 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine1AnyEdge_get", _wrap_EventControl_eventLine1AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 1 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 1 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine1AnyEdgeTimestamp_get", _wrap_EventControl_eventLine1AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 1 Any Edge Event.\n"
		"Returns the Timestamp of the Line 1 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine1AnyEdgeFrameID_get", _wrap_EventControl_eventLine1AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 1 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 1 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine2AnyEdge_get", _wrap_EventControl_eventLine2AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 2 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 2 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine2AnyEdgeTimestamp_get", _wrap_EventControl_eventLine2AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 2 Any Edge Event.\n"
		"Returns the Timestamp of the Line 2 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine2AnyEdgeFrameID_get", _wrap_EventControl_eventLine2AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 2 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 2 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine3AnyEdge_get", _wrap_EventControl_eventLine3AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 3 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 3 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine3AnyEdgeTimestamp_get", _wrap_EventControl_eventLine3AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 3 Any Edge Event.\n"
		"Returns the Timestamp of the Line 3 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine3AnyEdgeFrameID_get", _wrap_EventControl_eventLine3AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 3 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 3 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine4AnyEdge_get", _wrap_EventControl_eventLine4AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 4 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 4 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine4AnyEdgeTimestamp_get", _wrap_EventControl_eventLine4AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 4 Any Edge Event.\n"
		"Returns the Timestamp of the Line 4 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine4AnyEdgeFrameID_get", _wrap_EventControl_eventLine4AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 4 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 4 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine5AnyEdge_get", _wrap_EventControl_eventLine5AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 5 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 5 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine5AnyEdgeTimestamp_get", _wrap_EventControl_eventLine5AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 5 Any Edge Event.\n"
		"Returns the Timestamp of the Line 5 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine5AnyEdgeFrameID_get", _wrap_EventControl_eventLine5AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 5 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 5 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine6AnyEdge_get", _wrap_EventControl_eventLine6AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 6 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 6 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine6AnyEdgeTimestamp_get", _wrap_EventControl_eventLine6AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 6 Any Edge Event.\n"
		"Returns the Timestamp of the Line 6 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine6AnyEdgeFrameID_get", _wrap_EventControl_eventLine6AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 6 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 6 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine7AnyEdge_get", _wrap_EventControl_eventLine7AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 7 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 7 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine7AnyEdgeTimestamp_get", _wrap_EventControl_eventLine7AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 7 Any Edge Event.\n"
		"Returns the Timestamp of the Line 7 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine7AnyEdgeFrameID_get", _wrap_EventControl_eventLine7AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 7 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 7 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine8AnyEdge_get", _wrap_EventControl_eventLine8AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 8 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 8 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine8AnyEdgeTimestamp_get", _wrap_EventControl_eventLine8AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 8 Any Edge Event.\n"
		"Returns the Timestamp of the Line 8 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine8AnyEdgeFrameID_get", _wrap_EventControl_eventLine8AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 8 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 8 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine9AnyEdge_get", _wrap_EventControl_eventLine9AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 9 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 9 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine9AnyEdgeTimestamp_get", _wrap_EventControl_eventLine9AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 9 Any Edge Event.\n"
		"Returns the Timestamp of the Line 9 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine9AnyEdgeFrameID_get", _wrap_EventControl_eventLine9AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 9 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 9 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine10AnyEdge_get", _wrap_EventControl_eventLine10AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 10 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 10 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine10AnyEdgeTimestamp_get", _wrap_EventControl_eventLine10AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 10 Any Edge Event.\n"
		"Returns the Timestamp of the Line 10 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine10AnyEdgeFrameID_get", _wrap_EventControl_eventLine10AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 10 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 10 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine11AnyEdge_get", _wrap_EventControl_eventLine11AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 11 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 11 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine11AnyEdgeTimestamp_get", _wrap_EventControl_eventLine11AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 11 Any Edge Event.\n"
		"Returns the Timestamp of the Line 11 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine11AnyEdgeFrameID_get", _wrap_EventControl_eventLine11AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 11 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 11 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine12AnyEdge_get", _wrap_EventControl_eventLine12AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 12 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 12 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine12AnyEdgeTimestamp_get", _wrap_EventControl_eventLine12AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 12 Any Edge Event.\n"
		"Returns the Timestamp of the Line 12 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine12AnyEdgeFrameID_get", _wrap_EventControl_eventLine12AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 12 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 12 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine13AnyEdge_get", _wrap_EventControl_eventLine13AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 13 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 13 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine13AnyEdgeTimestamp_get", _wrap_EventControl_eventLine13AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 13 Any Edge Event.\n"
		"Returns the Timestamp of the Line 13 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine13AnyEdgeFrameID_get", _wrap_EventControl_eventLine13AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 13 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 13 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine14AnyEdge_get", _wrap_EventControl_eventLine14AnyEdge_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Line 14 Any Edge type of Event.\n"
		"Returns the unique Identifier of the Line 14 Any Edge type of Event.\n"
		""},
	 { "EventControl_eventLine14AnyEdgeTimestamp_get", _wrap_EventControl_eventLine14AnyEdgeTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Line 14 Any Edge Event.\n"
		"Returns the Timestamp of the Line 14 Any Edge Event.\n"
		""},
	 { "EventControl_eventLine14AnyEdgeFrameID_get", _wrap_EventControl_eventLine14AnyEdgeFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 14 Any Edge Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Line 14 Any Edge Event.\n"
		""},
	 { "EventControl_eventLinkTrigger0_get", _wrap_EventControl_eventLinkTrigger0_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 0 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 0 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger0Timestamp_get", _wrap_EventControl_eventLinkTrigger0Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 0 Event.\n"
		"Returns the Timestamp of the Link Trigger 0 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger0FrameID_get", _wrap_EventControl_eventLinkTrigger0FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 0 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 0 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger1_get", _wrap_EventControl_eventLinkTrigger1_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 1 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 1 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger1Timestamp_get", _wrap_EventControl_eventLinkTrigger1Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 1 Event.\n"
		"Returns the Timestamp of the Link Trigger 1 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger1FrameID_get", _wrap_EventControl_eventLinkTrigger1FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 1 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 1 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger2_get", _wrap_EventControl_eventLinkTrigger2_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 2 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 2 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger2Timestamp_get", _wrap_EventControl_eventLinkTrigger2Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 2 Event.\n"
		"Returns the Timestamp of the Link Trigger 2 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger2FrameID_get", _wrap_EventControl_eventLinkTrigger2FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 2 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 2 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger3_get", _wrap_EventControl_eventLinkTrigger3_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 3 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 3 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger3Timestamp_get", _wrap_EventControl_eventLinkTrigger3Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 3 Event.\n"
		"Returns the Timestamp of the Link Trigger 3 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger3FrameID_get", _wrap_EventControl_eventLinkTrigger3FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 3 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 3 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger4_get", _wrap_EventControl_eventLinkTrigger4_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 4 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 4 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger4Timestamp_get", _wrap_EventControl_eventLinkTrigger4Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 4 Event.\n"
		"Returns the Timestamp of the Link Trigger 4 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger4FrameID_get", _wrap_EventControl_eventLinkTrigger4FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 4 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 4 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger5_get", _wrap_EventControl_eventLinkTrigger5_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 5 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 5 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger5Timestamp_get", _wrap_EventControl_eventLinkTrigger5Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 5 Event.\n"
		"Returns the Timestamp of the Link Trigger 5 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger5FrameID_get", _wrap_EventControl_eventLinkTrigger5FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 5 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 5 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger6_get", _wrap_EventControl_eventLinkTrigger6_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 6 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 6 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger6Timestamp_get", _wrap_EventControl_eventLinkTrigger6Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 6 Event.\n"
		"Returns the Timestamp of the Link Trigger 6 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger6FrameID_get", _wrap_EventControl_eventLinkTrigger6FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 6 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 6 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger7_get", _wrap_EventControl_eventLinkTrigger7_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 7 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 7 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger7Timestamp_get", _wrap_EventControl_eventLinkTrigger7Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 7 Event.\n"
		"Returns the Timestamp of the Link Trigger 7 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger7FrameID_get", _wrap_EventControl_eventLinkTrigger7FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 7 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 7 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger8_get", _wrap_EventControl_eventLinkTrigger8_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 8 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 8 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger8Timestamp_get", _wrap_EventControl_eventLinkTrigger8Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 8 Event.\n"
		"Returns the Timestamp of the Link Trigger 8 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger8FrameID_get", _wrap_EventControl_eventLinkTrigger8FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 8 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 8 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger9_get", _wrap_EventControl_eventLinkTrigger9_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 9 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 9 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger9Timestamp_get", _wrap_EventControl_eventLinkTrigger9Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 9 Event.\n"
		"Returns the Timestamp of the Link Trigger 9 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger9FrameID_get", _wrap_EventControl_eventLinkTrigger9FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 9 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 9 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger10_get", _wrap_EventControl_eventLinkTrigger10_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 10 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 10 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger10Timestamp_get", _wrap_EventControl_eventLinkTrigger10Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 10 Event.\n"
		"Returns the Timestamp of the Link Trigger 10 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger10FrameID_get", _wrap_EventControl_eventLinkTrigger10FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 10 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 10 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger11_get", _wrap_EventControl_eventLinkTrigger11_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 11 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 11 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger11Timestamp_get", _wrap_EventControl_eventLinkTrigger11Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 11 Event.\n"
		"Returns the Timestamp of the Link Trigger 11 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger11FrameID_get", _wrap_EventControl_eventLinkTrigger11FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 11 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 11 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger12_get", _wrap_EventControl_eventLinkTrigger12_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 12 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 12 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger12Timestamp_get", _wrap_EventControl_eventLinkTrigger12Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 12 Event.\n"
		"Returns the Timestamp of the Link Trigger 12 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger12FrameID_get", _wrap_EventControl_eventLinkTrigger12FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 12 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 12 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger13_get", _wrap_EventControl_eventLinkTrigger13_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 13 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 13 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger13Timestamp_get", _wrap_EventControl_eventLinkTrigger13Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 13 Event.\n"
		"Returns the Timestamp of the Link Trigger 13 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger13FrameID_get", _wrap_EventControl_eventLinkTrigger13FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 13 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 13 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger14_get", _wrap_EventControl_eventLinkTrigger14_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Link Trigger 14 type of Event.\n"
		"Returns the unique Identifier of the Link Trigger 14 type of Event.\n"
		""},
	 { "EventControl_eventLinkTrigger14Timestamp_get", _wrap_EventControl_eventLinkTrigger14Timestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Link Trigger 14 Event.\n"
		"Returns the Timestamp of the Link Trigger 14 Event.\n"
		""},
	 { "EventControl_eventLinkTrigger14FrameID_get", _wrap_EventControl_eventLinkTrigger14FrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 14 Event.\n"
		"Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 14 Event.\n"
		""},
	 { "EventControl_eventError_get", _wrap_EventControl_eventError_get, METH_O, "\n"
		"An integer property. Returns the unique identifier of the Error type of Event.\n"
		"Returns the unique identifier of the Error type of Event. It can be used to register a callback function to be notified of the Error event occurrence. Its value uniquely identifies that the event received was an Error.\n"
		""},
	 { "EventControl_eventErrorTimestamp_get", _wrap_EventControl_eventErrorTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the Error Event.\n"
		"Returns the Timestamp of the Error Event. It can be used to determine when the event occurred.\n"
		""},
	 { "EventControl_eventErrorFrameID_get", _wrap_EventControl_eventErrorFrameID_get, METH_O, "\n"
		"An integer property. If applicable, returns the unique Identifier of the Frame (or image) that generated the Error Event.\n"
		"If applicable, returns the unique Identifier of the Frame (or image) that generated the Error Event.\n"
		""},
	 { "EventControl_eventErrorCode_get", _wrap_EventControl_eventErrorCode_get, METH_O, "\n"
		"An integer property. Returns an error code for the error(s) that happened.\n"
		"Returns an error code for the error(s) that happened.\n"
		""},
	 { "delete_EventControl", _wrap_delete_EventControl, METH_O, NULL},
	 { "EventControl_swigregister", EventControl_swigregister, METH_O, NULL},
	 { "EventControl_swiginit", EventControl_swiginit, METH_VARARGS, NULL},
	 { "new_UserSetControl", _wrap_new_UserSetControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::UserSetControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "UserSetControl_userSetSelector_get", _wrap_UserSetControl_userSetSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the feature User Set to load, save or configure.\n"
		"Selects the feature User Set to load, save or configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Default** (Display string: 'Default'): Selects the factory setting user set.\n"
		"- **UserSet0** (Display string: 'User Set 0'): Selects the user set 0.\n"
		"- **UserSet1** (Display string: 'User Set 1'): Selects the user set 1.\n"
		"- **UserSet2** (Display string: 'User Set 2'): Selects the user set 2.\n"
		"- **UserSet3** (Display string: 'User Set 3'): Selects the user set 3.\n"
		"- **UserSet4** (Display string: 'User Set 4'): Selects the user set 4.\n"
		"- **UserSet5** (Display string: 'User Set 5'): Selects the user set 5.\n"
		"- **UserSet6** (Display string: 'User Set 6'): Selects the user set 6.\n"
		"- **UserSet7** (Display string: 'User Set 7'): Selects the user set 7.\n"
		"- **UserSet8** (Display string: 'User Set 8'): Selects the user set 8.\n"
		"- **UserSet9** (Display string: 'User Set 9'): Selects the user set 9.\n"
		"- **UserSet10** (Display string: 'User Set 10'): Selects the user set 10.\n"
		"- **UserSet11** (Display string: 'User Set 11'): Selects the user set 11.\n"
		"- **UserSet12** (Display string: 'User Set 12'): Selects the user set 12.\n"
		"- **UserSet13** (Display string: 'User Set 13'): Selects the user set 13.\n"
		"- **UserSet14** (Display string: 'User Set 14'): Selects the user set 14.\n"
		"- **UserSet15** (Display string: 'User Set 15'): Selects the user set 15.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "UserSetControl_userSetDescription_get", _wrap_UserSetControl_userSetDescription_get, METH_O, "\n"
		"A string property. Description of the selected User Set content.\n"
		"Description of the selected User Set content.\n"
		""},
	 { "UserSetControl_userSetLoad_get", _wrap_UserSetControl_userSetLoad_get, METH_O, "\n"
		"A method object. Loads the User Set specified by UserSetSelector to the device and makes it active.\n"
		"Loads the User Set specified by UserSetSelector to the device and makes it active.\n"
		""},
	 { "UserSetControl_userSetSave_get", _wrap_UserSetControl_userSetSave_get, METH_O, "\n"
		"A method object. Save the User Set specified by UserSetSelector to the non-volatile memory of the device.\n"
		"Save the User Set specified by UserSetSelector to the non-volatile memory of the device.\n"
		""},
	 { "UserSetControl_userSetDefault_get", _wrap_UserSetControl_userSetDefault_get, METH_O, "\n"
		"An enumerated integer property. Selects the feature User Set to load and make active by default when the device is reset.\n"
		"Selects the feature User Set to load and make active by default when the device is reset.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Default** (Display string: 'Default'): Select the factory setting user set.\n"
		"- **UserSet0** (Display string: 'User Set 0'): Select the user set 0.\n"
		"- **UserSet1** (Display string: 'User Set 1'): Select the user set 1.\n"
		"- **UserSet2** (Display string: 'User Set 2'): Select the user set 2.\n"
		"- **UserSet3** (Display string: 'User Set 3'): Select the user set 3.\n"
		"- **UserSet4** (Display string: 'User Set 4'): Select the user set 4.\n"
		"- **UserSet5** (Display string: 'User Set 5'): Select the user set 5.\n"
		"- **UserSet6** (Display string: 'User Set 6'): Select the user set 6.\n"
		"- **UserSet7** (Display string: 'User Set 7'): Select the user set 7.\n"
		"- **UserSet8** (Display string: 'User Set 8'): Select the user set 8.\n"
		"- **UserSet9** (Display string: 'User Set 9'): Select the user set 9.\n"
		"- **UserSet10** (Display string: 'User Set 10'): Select the user set 10.\n"
		"- **UserSet11** (Display string: 'User Set 11'): Select the user set 11.\n"
		"- **UserSet12** (Display string: 'User Set 12'): Select the user set 12.\n"
		"- **UserSet13** (Display string: 'User Set 13'): Select the user set 13.\n"
		"- **UserSet14** (Display string: 'User Set 14'): Select the user set 14.\n"
		"- **UserSet15** (Display string: 'User Set 15'): Select the user set 15.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "UserSetControl_userSetDefaultSelector_get", _wrap_UserSetControl_userSetDefaultSelector_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated (See UserSetDefault).\n"
		"Deprecated: \n"
		"This feature is deprecated (See UserSetDefault). Selects the feature User Set to load and make active when the device is reset.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Default** (Display string: 'Default'): Select the factory setting user set.\n"
		"- **UserSet0** (Display string: 'User Set 0'): Select the user set 0.\n"
		"- **UserSet1** (Display string: 'User Set 1'): Select the user set 1.\n"
		"- **UserSet2** (Display string: 'User Set 2'): Select the user set 2.\n"
		"- **UserSet3** (Display string: 'User Set 3'): Select the user set 3.\n"
		"- **UserSet4** (Display string: 'User Set 4'): Select the user set 4.\n"
		"- **UserSet5** (Display string: 'User Set 5'): Select the user set 5.\n"
		"- **UserSet6** (Display string: 'User Set 6'): Select the user set 6.\n"
		"- **UserSet7** (Display string: 'User Set 7'): Select the user set 7.\n"
		"- **UserSet8** (Display string: 'User Set 8'): Select the user set 8.\n"
		"- **UserSet9** (Display string: 'User Set 9'): Select the user set 9.\n"
		"- **UserSet10** (Display string: 'User Set 10'): Select the user set 10.\n"
		"- **UserSet11** (Display string: 'User Set 11'): Select the user set 11.\n"
		"- **UserSet12** (Display string: 'User Set 12'): Select the user set 12.\n"
		"- **UserSet13** (Display string: 'User Set 13'): Select the user set 13.\n"
		"- **UserSet14** (Display string: 'User Set 14'): Select the user set 14.\n"
		"- **UserSet15** (Display string: 'User Set 15'): Select the user set 15.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "UserSetControl_userSetFeatureSelector_get", _wrap_UserSetControl_userSetFeatureSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which individual UserSet feature to control.\n"
		"Selects which individual UserSet feature to control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Device-Specific-Feature-List** (Display string: 'Device - Specific - Feature - List'): Device - Specific - Feature - List\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "UserSetControl_userSetFeatureEnable_get", _wrap_UserSetControl_userSetFeatureEnable_get, METH_O, "\n"
		"A boolean property. Enables the selected feature and make it active in all the UserSets.\n"
		"Enables the selected feature and make it active in all the UserSets.\n"
		""},
	 { "UserSetControl_mvUserData_get", _wrap_UserSetControl_mvUserData_get, METH_O, "\n"
		"A string property. A register to store arbitrary user data into the devices non-volatile memory. The data is stored as binary data encoded in Base64 see mvIMPACT::acquire::PropertyS::writeBinary or mvIMPACT::acquire::PropertyS::readBinary for more details.\n"
		"A register to store arbitrary user data into the devices non-volatile memory. The data is stored as binary data encoded in Base64 see mvIMPACT::acquire::PropertyS::writeBinary or mvIMPACT::acquire::PropertyS::readBinary for more details.\n"
		""},
	 { "delete_UserSetControl", _wrap_delete_UserSetControl, METH_O, NULL},
	 { "UserSetControl_swigregister", UserSetControl_swigregister, METH_O, NULL},
	 { "UserSetControl_swiginit", UserSetControl_swiginit, METH_VARARGS, NULL},
	 { "new_SequencerControl", _wrap_new_SequencerControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::SequencerControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "SequencerControl_sequencerMode_get", _wrap_SequencerControl_sequencerMode_get, METH_O, "\n"
		"An enumerated integer property. Controls if the sequencer mechanism is active.\n"
		"Controls if the sequencer mechanism is active.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **On** (Display string: 'On'): Enables the sequencer.\n"
		"- **Off** (Display string: 'Off'): Disables the sequencer.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SequencerControl_sequencerConfigurationMode_get", _wrap_SequencerControl_sequencerConfigurationMode_get, METH_O, "\n"
		"An enumerated integer property. Controls if the sequencer configuration mode is active.\n"
		"Controls if the sequencer configuration mode is active.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **On** (Display string: 'On'): Enables the sequencer configuration mode.\n"
		"- **Off** (Display string: 'Off'): Disables the sequencer configuration mode.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SequencerControl_sequencerFeatureSelector_get", _wrap_SequencerControl_sequencerFeatureSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which sequencer features to control.\n"
		"Selects which sequencer features to control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Device-Specific-Feature-List** (Display string: 'Device - Specific - Feature - List'): Device - Specific - Feature - List\n"
		"- **ExposureTime** (Display string: 'Exposure Time')\n"
		"- **CounterDuration** (Display string: 'Counter Duration')\n"
		"- **mvImagePositionAndSize** (Display string: 'mv Image Position And Size'): This value selects whether features affecting the image position and size shall be controlled by the sequencer.\n"
		"- **Width** (Display string: 'Width')\n"
		"- **Height** (Display string: 'Height')\n"
		"- **OffsetX** (Display string: 'Offset X')\n"
		"- **OffsetY** (Display string: 'Offset Y')\n"
		"- **BinningHorizontal** (Display string: 'Binning Horizontal')\n"
		"- **BinningVertical** (Display string: 'Binning Vertical')\n"
		"- **DecimationHorizontal** (Display string: 'Decimation Horizontal')\n"
		"- **DecimationVertical** (Display string: 'Decimation Vertical')\n"
		"- **Gain** (Display string: 'Gain')\n"
		"- **UserOutputValueAll** (Display string: 'User Output Value All')\n"
		"- **UserOutputValueAllMask** (Display string: 'User Output Value All Mask')\n"
		"- **mvUserOutput** (Display string: 'mv User Output'): This value selects whether features affecting the user outputs shall be controlled by the sequencer.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SequencerControl_sequencerFeatureEnable_get", _wrap_SequencerControl_sequencerFeatureEnable_get, METH_O, "\n"
		"A boolean property. Enables the selected feature and make it active in all the sequencer sets.\n"
		"Enables the selected feature and make it active in all the sequencer sets.\n"
		""},
	 { "SequencerControl_sequencerSetSelector_get", _wrap_SequencerControl_sequencerSetSelector_get, METH_O, "\n"
		"An integer property. Selects the sequencer set to which further feature settings applies.\n"
		"Selects the sequencer set to which further feature settings applies.\n"
		""},
	 { "SequencerControl_sequencerSetSave_get", _wrap_SequencerControl_sequencerSetSave_get, METH_O, "\n"
		"A method object. Saves the current device state to the sequencer set selected by the SequencerSetSelector.\n"
		"Saves the current device state to the sequencer set selected by the SequencerSetSelector.\n"
		""},
	 { "SequencerControl_sequencerSetLoad_get", _wrap_SequencerControl_sequencerSetLoad_get, METH_O, "\n"
		"A method object. Loads the sequencer set selected by SequencerSetSelector in the device.\n"
		"Loads the sequencer set selected by SequencerSetSelector in the device. Even if SequencerMode is off, this will change the device state to the configuration of the selected set.\n"
		""},
	 { "SequencerControl_sequencerSetActive_get", _wrap_SequencerControl_sequencerSetActive_get, METH_O, "\n"
		"An integer property. Contains the currently active sequencer set.\n"
		"Contains the currently active sequencer set.\n"
		""},
	 { "SequencerControl_sequencerSetStart_get", _wrap_SequencerControl_sequencerSetStart_get, METH_O, "\n"
		"An integer property. Sets the initial/start sequencer set, which is the first set used within a sequencer.\n"
		"Sets the initial/start sequencer set, which is the first set used within a sequencer.\n"
		""},
	 { "SequencerControl_sequencerPathSelector_get", _wrap_SequencerControl_sequencerPathSelector_get, METH_O, "\n"
		"An integer property. Selects to which branching path further path settings applies.\n"
		"Selects to which branching path further path settings applies.\n"
		""},
	 { "SequencerControl_sequencerSetNext_get", _wrap_SequencerControl_sequencerSetNext_get, METH_O, "\n"
		"An integer property. Specifies the next sequencer set.\n"
		"Specifies the next sequencer set.\n"
		""},
	 { "SequencerControl_sequencerTriggerSource_get", _wrap_SequencerControl_sequencerTriggerSource_get, METH_O, "\n"
		"An enumerated integer property. Specifies the internal signal or physical input line to use as the sequencer trigger source.\n"
		"Specifies the internal signal or physical input line to use as the sequencer trigger source.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Starts with the reception of the Acquisition End.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Starts with the reception of the Acquisition Start.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Starts with the reception of the Acquisition Trigger.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Starts with the reception of the missed Acquisition Trigger.\n"
		"- **Action0** (Display string: 'Action 0'): Starts with the assertion of the chosen action signal.\n"
		"- **Action1** (Display string: 'Action 1'): Starts with the assertion of the chosen action signal.\n"
		"- **Action2** (Display string: 'Action 2'): Starts with the assertion of the chosen action signal.\n"
		"- **CC1** (Display string: 'CC 1'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC2** (Display string: 'CC 2'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC3** (Display string: 'CC 3'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **CC4** (Display string: 'CC 4'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): Starts with the reception of the Counter End.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): Starts with the reception of the Counter Start.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): Starts with the reception of the Counter End.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): Starts with the reception of the Counter Start.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): Starts with the reception of the Counter End.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): Starts with the reception of the Counter Start.\n"
		"- **Encoder0** (Display string: 'Encoder 0'): Starts with the reception of the Encoder output signal.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): Starts with the reception of the Encoder output signal.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): Starts with the reception of the Encoder output signal.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Starts with the reception of the Exposure End.\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Starts with the reception of the Exposure Start.\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Starts with the reception of the Frame Burst End.\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Starts with the reception of the Frame Burst Start.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Starts with the reception of the Frame End.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Starts with the reception of the Frame Start.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Starts with the reception of the Frame Start Trigger.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Starts with the reception of the missed Frame Trigger.\n"
		"- **Line0** (Display string: 'Line 0'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line1** (Display string: 'Line 1'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **Line2** (Display string: 'Line 2'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): Starts with the reception of the chosen Link Trigger.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): Starts with the reception of the chosen Link Trigger.\n"
		"- **LinkTrigger2** (Display string: 'Link Trigger 2'): Starts with the reception of the chosen Link Trigger.\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): Starts with the reception of the Logic Block output signal.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): Starts with the reception of the Logic Block output signal.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): Starts with the reception of the Logic Block output signal.\n"
		"- **Off** (Display string: 'Off'): Disables the sequencer trigger.\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): Starts on the reception of the Software Signal.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): Starts on the reception of the Software Signal.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): Starts on the reception of the Software Signal.\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): Starts with the reception of the Timer End.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): Starts with the reception of the Timer Start.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): Starts with the reception of the Timer End.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): Starts with the reception of the Timer Start.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): Starts with the reception of the Timer End.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): Starts with the reception of the Timer Start.\n"
		"- **UserOutput0** (Display string: 'User Output 0'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput1** (Display string: 'User Output 1'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"- **UserOutput2** (Display string: 'User Output 2'): Specifies which User Output bit signal to use as internal source for the trigger.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SequencerControl_sequencerTriggerActivation_get", _wrap_SequencerControl_sequencerTriggerActivation_get, METH_O, "\n"
		"An enumerated integer property. Specifies the activation mode of the sequencer trigger.\n"
		"Specifies the activation mode of the sequencer trigger.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RisingEdge** (Display string: 'Rising Edge'): Specifies that the trigger is considered valid on the rising edge of the source signal.\n"
		"- **FallingEdge** (Display string: 'Falling Edge'): Specifies that the trigger is considered valid on the falling edge of the source signal.\n"
		"- **AnyEdge** (Display string: 'Any Edge'): Specifies that the trigger is considered valid on the falling or rising edge of the source signal.\n"
		"- **LevelHigh** (Display string: 'Level High'): Specifies that the trigger is considered valid as long as the level of the source signal is high.\n"
		"- **LevelLow** (Display string: 'Level Low'): Specifies that the trigger is considered valid as long as the level of the source signal is low.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_SequencerControl", _wrap_delete_SequencerControl, METH_O, NULL},
	 { "SequencerControl_swigregister", SequencerControl_swigregister, METH_O, NULL},
	 { "SequencerControl_swiginit", SequencerControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvDefectivePixelCorrectionControl", _wrap_new_mvDefectivePixelCorrectionControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvDefectivePixelCorrectionControl_mvDefectPixelThreshold_get", _wrap_mvDefectivePixelCorrectionControl_mvDefectPixelThreshold_get, METH_O, "\n"
		"An integer property. Sets the threshold for the defect pixel detection.\n"
		"Sets the threshold for the defect pixel detection.\n"
		""},
	 { "mvDefectivePixelCorrectionControl_mvDefectivePixelEnable_get", _wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelEnable_get, METH_O, "\n"
		"A boolean property. Activates the camera's defective pixel correction.\n"
		"Activates the camera's defective pixel correction.\n"
		""},
	 { "mvDefectivePixelCorrectionControl_mvDefectivePixelBlinkingMode_get", _wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelBlinkingMode_get, METH_O, "\n"
		"A boolean property. Activates the blinking mode of the camera's defective pixel correction.\n"
		"Activates the blinking mode of the camera's defective pixel correction.\n"
		""},
	 { "mvDefectivePixelCorrectionControl_mvDefectivePixelSelector_get", _wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelSelector_get, METH_O, "\n"
		"An integer property. Controls the index (offset) of the defective pixel to access.\n"
		"Controls the index (offset) of the defective pixel to access. Data selected by this selector is NOT part of a user set, but must be written to non volatile memory by calling 'mvDefectivePixelDataSave' explicitly.\n"
		""},
	 { "mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetX_get", _wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetX_get, METH_O, "\n"
		"An integer property. Returns the horizontal offset of the defective pixel selected by mvDefectivePixelSelector.\n"
		"Returns the horizontal offset of the defective pixel selected by mvDefectivePixelSelector. This data is NOT part of a user set, but must be written to non volatile memory by calling 'mvDefectivePixelDataSave' explicitly.\n"
		""},
	 { "mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetY_get", _wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetY_get, METH_O, "\n"
		"An integer property. Returns the vertical offset of the defective pixel selected by mvDefectivePixelSelector.\n"
		"Returns the vertical offset of the defective pixel selected by mvDefectivePixelSelector. This data is NOT part of a user set, but must be written to non volatile memory by calling 'mvDefectivePixelDataSave' explicitly.\n"
		""},
	 { "mvDefectivePixelCorrectionControl_mvDefectivePixelCount_get", _wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelCount_get, METH_O, "\n"
		"An integer property. Contains the number of valid defective pixels. Increasing this value adds a new empty entry. Decreasing this value deletes the last entry.\n"
		"Contains the number of valid defective pixels. Increasing this value adds a new empty entry. Decreasing this value deletes the last entry.\n"
		""},
	 { "mvDefectivePixelCorrectionControl_mvDefectivePixelDataLoad_get", _wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelDataLoad_get, METH_O, "\n"
		"A method object. Loads the defective pixels from device non volatile memory.\n"
		"Loads the defective pixels from device non volatile memory.\n"
		""},
	 { "mvDefectivePixelCorrectionControl_mvDefectivePixelDataSave_get", _wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelDataSave_get, METH_O, "\n"
		"A method object. Saves the defective pixels to device non volatile memory.\n"
		"Saves the defective pixels to device non volatile memory.\n"
		""},
	 { "delete_mvDefectivePixelCorrectionControl", _wrap_delete_mvDefectivePixelCorrectionControl, METH_O, NULL},
	 { "mvDefectivePixelCorrectionControl_swigregister", mvDefectivePixelCorrectionControl_swigregister, METH_O, NULL},
	 { "mvDefectivePixelCorrectionControl_swiginit", mvDefectivePixelCorrectionControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvAutoFeatureControl", _wrap_new_mvAutoFeatureControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvAutoFeatureControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureBrightness_get", _wrap_mvAutoFeatureControl_mvAutoFeatureBrightness_get, METH_O, "\n"
		"An integer property. Common desired average brightness value (in percent) used for Auto Gain Control(AGC) and Auto Exposure Control(AEC). At least one of these controllers must be activated for the value to take effect.\n"
		"Common desired average brightness value (in percent) used for Auto Gain Control(AGC) and Auto Exposure Control(AEC). At least one of these controllers must be activated for the value to take effect.\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureSensitivity_get", _wrap_mvAutoFeatureControl_mvAutoFeatureSensitivity_get, METH_O, "\n"
		"An integer property. The controllers sensitivity of brightness deviations. This parameter influences the gain as well as the exposure controller. At least one of these controllers must be activated for the value to take effect.\n"
		"The controllers sensitivity of brightness deviations. This parameter influences the gain as well as the exposure controller. At least one of these controllers must be activated for the value to take effect.\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureCharacteristic_get", _wrap_mvAutoFeatureControl_mvAutoFeatureCharacteristic_get, METH_O, "\n"
		"An enumerated integer property. Selects the prioritization between Auto Exposure Control(AEC) and Auto Gain Control(AGC) controller. Both controllers have to be activated before.\n"
		"Selects the prioritization between Auto Exposure Control(AEC) and Auto Gain Control(AGC) controller. Both controllers have to be activated before.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLowGain** (Display string: 'mv Low Gain')\n"
		"- **mvShortExposure** (Display string: 'mv Short Exposure')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureBrightnessCalculation_get", _wrap_mvAutoFeatureControl_mvAutoFeatureBrightnessCalculation_get, METH_O, "\n"
		"An enumerated integer property. Selects the method to determine the brightness for Auto Exposure Control(AEC) and Auto Gain Control(AGC) controller.\n"
		"Selects the method to determine the brightness for Auto Exposure Control(AEC) and Auto Gain Control(AGC) controller.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvPeak** (Display string: 'mv Peak'): The peak brightness value is used as actual value for the controller.\n"
		"- **mvAverage** (Display string: 'mv Average'): The average brightness is used as actual value for the controller.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureAOIHighlightEnable_get", _wrap_mvAutoFeatureControl_mvAutoFeatureAOIHighlightEnable_get, METH_O, "\n"
		"An enumerated integer property. Highlight auto control AOI to check AOI settings. Switch off for normal operation.\n"
		"Highlight auto control AOI to check AOI settings. Switch off for normal operation.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The AutoFeatureAOIHighlight is switched off.\n"
		"- **On** (Display string: 'On'): The AutoFeatureAOIHighlight is switched on.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureAOIMode_get", _wrap_mvAutoFeatureControl_mvAutoFeatureAOIMode_get, METH_O, "\n"
		"An enumerated integer property. Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balancing.\n"
		"Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balancing.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvFull** (Display string: 'mv Full'): The auto controller uses the full frame for the actual value computation.\n"
		"- **mvCenter** (Display string: 'mv Center'): The auto controller uses a centered AOI of 25% the full frame for the actual value computation.\n"
		"- **mvUser** (Display string: 'mv User'): The auto controller uses the user defined AOI for the actual value computation.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureAOIOffsetX_get", _wrap_mvAutoFeatureControl_mvAutoFeatureAOIOffsetX_get, METH_O, "\n"
		"An integer property. Common AOI X-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI X-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureAOIOffsetY_get", _wrap_mvAutoFeatureControl_mvAutoFeatureAOIOffsetY_get, METH_O, "\n"
		"An integer property. Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureAOIWidth_get", _wrap_mvAutoFeatureControl_mvAutoFeatureAOIWidth_get, METH_O, "\n"
		"An integer property. Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureAOIHeight_get", _wrap_mvAutoFeatureControl_mvAutoFeatureAOIHeight_get, METH_O, "\n"
		"An integer property. Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		"Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).\n"
		""},
	 { "mvAutoFeatureControl_mvAutoFeatureBrightnessTolerance_get", _wrap_mvAutoFeatureControl_mvAutoFeatureBrightnessTolerance_get, METH_O, "\n"
		"An integer property. The error input hysteresis width of the controller. If the brightness error exceeds the half of the value in positive or negative direction, the controller restarts to control the brightness. This property applies to AEC and AGC as well.\n"
		"The error input hysteresis gap of the controller. If the brightness error exceeds the half of the value in positive or negative direction, the controller restarts to control the brightness. This property applies to AEC and AGC as well.\n"
		""},
	 { "delete_mvAutoFeatureControl", _wrap_delete_mvAutoFeatureControl, METH_O, NULL},
	 { "mvAutoFeatureControl_swigregister", mvAutoFeatureControl_swigregister, METH_O, NULL},
	 { "mvAutoFeatureControl_swiginit", mvAutoFeatureControl_swiginit, METH_VARARGS, NULL},
	 { "new_FileAccessControl", _wrap_new_FileAccessControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::FileAccessControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "FileAccessControl_fileSelector_get", _wrap_FileAccessControl_fileSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the target file in the device.\n"
		"Selects the target file in the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **DeviceFirmware** (Display string: 'Device Firmware')\n"
		"- **LUTBlue** (Display string: 'LUT Blue'): The Blue LUT of the camera.\n"
		"- **LUTGreen** (Display string: 'LUT Green'): The Green LUT of the camera.\n"
		"- **LUTLuminance** (Display string: 'LUT Luminance'): The Luminance LUT of the camera.\n"
		"- **LUTRed** (Display string: 'LUT Red'): The Red LUT of the camera.\n"
		"- **UserFile** (Display string: 'User File')\n"
		"- **UserSet1** (Display string: 'User Set 1'): The first user set of the device.\n"
		"- **UserSet2** (Display string: 'User Set 2'): The second user set of the device.\n"
		"- **UserSet3** (Display string: 'User Set 3'): The third user set of the device.\n"
		"- **UserSetDefault** (Display string: 'User Set Default'): The default user set of the device.\n"
		"- **mvFFCImage** (Display string: 'mv FFC Image')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "FileAccessControl_fileOperationSelector_get", _wrap_FileAccessControl_fileOperationSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the target operation for the selected file in the device.\n"
		"Selects the target operation for the selected file in the device. This Operation is executed when the FileOperationExecute feature is called.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Open** (Display string: 'Open'): Opens the file selected by FileSelector in the device. The access mode in which the file is opened is selected by FileOpenMode.\n"
		"- **Close** (Display string: 'Close'): Closes the file selected by FileSelector in the device.\n"
		"- **Read** (Display string: 'Read'): Reads FileAccessLength bytes from the device storage at the file relative offset FileAccessOffset into FileAccessBuffer.\n"
		"- **Write** (Display string: 'Write'): Writes FileAccessLength bytes taken from the FileAccessBuffer into the device storage at the file relative offset FileAccessOffset.\n"
		"- **Delete** (Display string: 'Delete'): Deletes the file selected by FileSelector in the device. Note that deleting a device file should not remove the associated FileSelector entry to allow future operation on this file.\n"
		"- **MvFlashWrite** (Display string: 'Mv Flash Write')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "FileAccessControl_fileOperationExecute_get", _wrap_FileAccessControl_fileOperationExecute_get, METH_O, "\n"
		"A method object. Executes the operation selected by FileOperationSelector on the selected file.\n"
		"Executes the operation selected by FileOperationSelector on the selected file.\n"
		""},
	 { "FileAccessControl_fileOpenMode_get", _wrap_FileAccessControl_fileOpenMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the access mode in which a file is opened in the device.\n"
		"Selects the access mode in which a file is opened in the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Read** (Display string: 'Read'): This mode selects read-only open mode.\n"
		"- **Write** (Display string: 'Write'): This mode selects write-only open mode.\n"
		"- **ReadWrite** (Display string: 'Read Write'): This mode selects read and write open mode.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "FileAccessControl_fileAccessBuffer_get", _wrap_FileAccessControl_fileAccessBuffer_get, METH_O, "\n"
		"A string property. Defines the intermediate access buffer that allows the exchange of data between the device file storage and the application.\n"
		"Defines the intermediate access buffer that allows the exchange of data between the device file storage and the application.\n"
		""},
	 { "FileAccessControl_fileAccessOffset_get", _wrap_FileAccessControl_fileAccessOffset_get, METH_O, "\n"
		"An integer property. Controls the Offset of the mapping between the device file storage and the FileAccessBuffer.\n"
		"Controls the Offset of the mapping between the device file storage and the FileAccessBuffer.\n"
		""},
	 { "FileAccessControl_fileAccessLength_get", _wrap_FileAccessControl_fileAccessLength_get, METH_O, "\n"
		"An integer property. Controls the Length of the mapping between the device file storage and the FileAccessBuffer.\n"
		"Controls the Length of the mapping between the device file storage and the FileAccessBuffer.\n"
		""},
	 { "FileAccessControl_fileOperationStatus_get", _wrap_FileAccessControl_fileOperationStatus_get, METH_O, "\n"
		"An enumerated integer property. Represents the file operation execution status.\n"
		"Represents the file operation execution status.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Success** (Display string: 'Success'): File Operation was successful.\n"
		"- **Failure** (Display string: 'Failure'): File Operation failed.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "FileAccessControl_fileOperationResult_get", _wrap_FileAccessControl_fileOperationResult_get, METH_O, "\n"
		"An integer property. Represents the file operation result.\n"
		"Represents the file operation result. For Read or Write operations, the number of successfully read/written bytes is returned.\n"
		""},
	 { "FileAccessControl_fileSize_get", _wrap_FileAccessControl_fileSize_get, METH_O, "\n"
		"An integer property. Represents the size of the selected file in bytes.\n"
		"Represents the size of the selected file in bytes.\n"
		""},
	 { "delete_FileAccessControl", _wrap_delete_FileAccessControl, METH_O, NULL},
	 { "FileAccessControl_swigregister", FileAccessControl_swigregister, METH_O, NULL},
	 { "FileAccessControl_swiginit", FileAccessControl_swiginit, METH_VARARGS, NULL},
	 { "new_SourceControl", _wrap_new_SourceControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::SourceControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "SourceControl_sourceCount_get", _wrap_SourceControl_sourceCount_get, METH_O, "\n"
		"An integer property. Controls or returns the number of sources supported by the device.\n"
		"Controls or returns the number of sources supported by the device.\n"
		""},
	 { "SourceControl_sourceSelector_get", _wrap_SourceControl_sourceSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the source to control.\n"
		"Selects the source to control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): Selects all the data sources.\n"
		"- **Source0** (Display string: 'Source 0'): Selects the data source 0.\n"
		"- **Source1** (Display string: 'Source 1'): Selects the data source 1.\n"
		"- **Source2** (Display string: 'Source 2'): Selects the data source 2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SourceControl_sourceIDValue_get", _wrap_SourceControl_sourceIDValue_get, METH_O, "\n"
		"An integer property. Returns a unique Identifier value that correspond to the selected Source.\n"
		"Returns a unique Identifier value that correspond to the selected Source.\n"
		""},
	 { "delete_SourceControl", _wrap_delete_SourceControl, METH_O, NULL},
	 { "SourceControl_swigregister", SourceControl_swigregister, METH_O, NULL},
	 { "SourceControl_swiginit", SourceControl_swiginit, METH_VARARGS, NULL},
	 { "new_TransferControl", _wrap_new_TransferControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::TransferControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "TransferControl_transferSelector_get", _wrap_TransferControl_transferSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which stream transfers are currently controlled by the selected Transfer features.\n"
		"Selects which stream transfers are currently controlled by the selected Transfer features.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): The transfer features control all the data streams simultaneously.\n"
		"- **Stream0** (Display string: 'Stream 0'): The transfer features control the data stream 0.\n"
		"- **Stream1** (Display string: 'Stream 1'): The transfer features control the data stream 1.\n"
		"- **Stream2** (Display string: 'Stream 2'): The transfer features control the data stream 2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferControlMode_get", _wrap_TransferControl_transferControlMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the control method for the transfers.\n"
		"Selects the control method for the transfers.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Basic** (Display string: 'Basic'): Basic\n"
		"- **Automatic** (Display string: 'Automatic'): Automatic\n"
		"- **UserControlled** (Display string: 'User Controlled'): User Controlled\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferOperationMode_get", _wrap_TransferControl_transferOperationMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the operation mode of the transfer.\n"
		"Selects the operation mode of the transfer.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Continuous** (Display string: 'Continuous'): Continuous\n"
		"- **MultiBlock** (Display string: 'Multi Block'): Multi Block\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferBlockCount_get", _wrap_TransferControl_transferBlockCount_get, METH_O, "\n"
		"An integer property. Specifies the number of data Blocks that the device should stream before stopping.\n"
		"Specifies the number of data Blocks that the device should stream before stopping. This feature is only active if the TransferOperationMode is set to MultiBlock.\n"
		""},
	 { "TransferControl_transferBurstCount_get", _wrap_TransferControl_transferBurstCount_get, METH_O, "\n"
		"An integer property. Number of Block(s) to transfer for each TransferBurstStart trigger.\n"
		"Number of Block(s) to transfer for each TransferBurstStart trigger.\n"
		""},
	 { "TransferControl_transferQueueMaxBlockCount_get", _wrap_TransferControl_transferQueueMaxBlockCount_get, METH_O, "\n"
		"An integer property. Controls the maximum number of data blocks that can be stored in the block queue of the selected stream.\n"
		"Controls the maximum number of data blocks that can be stored in the block queue of the selected stream.\n"
		""},
	 { "TransferControl_transferQueueCurrentBlockCount_get", _wrap_TransferControl_transferQueueCurrentBlockCount_get, METH_O, "\n"
		"An integer property. Returns the number of Block(s) currently in the transfer queue.\n"
		"Returns the number of Block(s) currently in the transfer queue.\n"
		""},
	 { "TransferControl_transferQueueMode_get", _wrap_TransferControl_transferQueueMode_get, METH_O, "\n"
		"An enumerated integer property. Specifies the operation mode of the transfer queue.\n"
		"Specifies the operation mode of the transfer queue.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **FirstInFirstOut** (Display string: 'First In First Out'): Blocks first In are transferred Out first.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferStart_get", _wrap_TransferControl_transferStart_get, METH_O, "\n"
		"A method object. Starts the streaming of data blocks out of the device.\n"
		"Starts the streaming of data blocks out of the device. This feature must be available when the TransferControlMode is set to 'UserControlled'. If the TransferStart feature is not writable (locked), the application should not start the transfer and should avoid using the feature until it becomes writable again.\n"
		""},
	 { "TransferControl_transferStop_get", _wrap_TransferControl_transferStop_get, METH_O, "\n"
		"A method object. Stops the streaming of data Block(s).\n"
		"Stops the streaming of data Block(s). The current block transmission will be completed. This feature must be available when the TransferControlMode is set to 'UserControlled'.\n"
		""},
	 { "TransferControl_transferAbort_get", _wrap_TransferControl_transferAbort_get, METH_O, "\n"
		"A method object. Aborts immediately the streaming of data block(s).\n"
		"Aborts immediately the streaming of data block(s). Aborting the transfer will result in the lost of the data that is present or currently entering in the block queue. However, the next new block received will be stored in the queue and transferred to the host when the streaming is restarted. If implemented, this feature should be available when the TransferControlMode is set to 'UserControlled'.\n"
		""},
	 { "TransferControl_transferPause_get", _wrap_TransferControl_transferPause_get, METH_O, "\n"
		"A method object. Pauses the streaming of data Block(s).\n"
		"Pauses the streaming of data Block(s). Pausing the streaming will immediately suspend the ongoing data transfer even if a block is partially transfered. The device will resume its transmission at the reception of a TransferResume command.\n"
		""},
	 { "TransferControl_transferResume_get", _wrap_TransferControl_transferResume_get, METH_O, "\n"
		"A method object. Resumes a data Blocks streaming that was previously paused by a TransferPause command.\n"
		"Resumes a data Blocks streaming that was previously paused by a TransferPause command.\n"
		""},
	 { "TransferControl_transferTriggerSelector_get", _wrap_TransferControl_transferTriggerSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the type of transfer trigger to configure.\n"
		"Selects the type of transfer trigger to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **TransferStart** (Display string: 'Transfer Start'): Selects a trigger to start the transfers.\n"
		"- **TransferStop** (Display string: 'Transfer Stop'): Selects a trigger to stop the transfers.\n"
		"- **TransferAbort** (Display string: 'Transfer Abort'): Selects a trigger to abort the transfers.\n"
		"- **TransferPause** (Display string: 'Transfer Pause'): Selects a trigger to pause the transfers.\n"
		"- **TransferResume** (Display string: 'Transfer Resume'): Selects a trigger to Resume the transfers.\n"
		"- **TransferActive** (Display string: 'Transfer Active'): Selects a trigger to Activate the transfers. This trigger type is used when TriggerActivation is set LevelHigh or levelLow.\n"
		"- **TransferBurstStart** (Display string: 'Transfer Burst Start'): Selects a trigger to start the transfer of a burst of frames specified by TransferBurstCount.\n"
		"- **TransferBurstStop** (Display string: 'Transfer Burst Stop'): Selects a trigger to end the transfer of a burst of frames.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferTriggerMode_get", _wrap_TransferControl_transferTriggerMode_get, METH_O, "\n"
		"An enumerated integer property. Controls if the selected trigger is active.\n"
		"Controls if the selected trigger is active.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Disables the selected trigger.\n"
		"- **On** (Display string: 'On'): Enable the selected trigger.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferTriggerSource_get", _wrap_TransferControl_transferTriggerSource_get, METH_O, "\n"
		"An enumerated integer property. Specifies the signal to use as the trigger source for transfers.\n"
		"Specifies the signal to use as the trigger source for transfers.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Action0** (Display string: 'Action 0'): Specifies which Action command to use as internal source for the transfer control trigger signal.\n"
		"- **Action1** (Display string: 'Action 1'): Specifies which Action command to use as internal source for the transfer control trigger signal.\n"
		"- **Action2** (Display string: 'Action 2'): Specifies which Action command to use as internal source for the transfer control trigger signal.\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.\n"
		"- **Line0** (Display string: 'Line 0'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the transfer control trigger signal.\n"
		"- **Line1** (Display string: 'Line 1'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the transfer control trigger signal.\n"
		"- **Line2** (Display string: 'Line 2'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the transfer control trigger signal.\n"
		"- **LogicBlock0** (Display string: 'Logic Block 0'): Specifies which Logic Block to use as internal source for the transfer control trigger signal.\n"
		"- **LogicBlock1** (Display string: 'Logic Block 1'): Specifies which Logic Block to use as internal source for the transfer control trigger signal.\n"
		"- **LogicBlock2** (Display string: 'Logic Block 2'): Specifies which Logic Block to use as internal source for the transfer control trigger signal.\n"
		"- **SoftwareSignal0** (Display string: 'Software Signal 0'): Specifies which Software Signal to use as internal source for the transfer control trigger signal.\n"
		"- **SoftwareSignal1** (Display string: 'Software Signal 1'): Specifies which Software Signal to use as internal source for the transfer control trigger signal.\n"
		"- **SoftwareSignal2** (Display string: 'Software Signal 2'): Specifies which Software Signal to use as internal source for the transfer control trigger signal.\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferTriggerActivation_get", _wrap_TransferControl_transferTriggerActivation_get, METH_O, "\n"
		"An enumerated integer property. Specifies the activation mode of the transfer control trigger.\n"
		"Specifies the activation mode of the transfer control trigger.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RisingEdge** (Display string: 'Rising Edge'): Specifies that the trigger is considered valid on the rising edge of the source signal.\n"
		"- **FallingEdge** (Display string: 'Falling Edge'): Specifies that the trigger is considered valid on the falling edge of the source signal.\n"
		"- **AnyEdge** (Display string: 'Any Edge'): Specifies that the trigger is considered valid on the falling or rising edge of the source signal.\n"
		"- **LevelHigh** (Display string: 'Level High'): Specifies that the trigger is considered valid as long as the level of the source signal is high. This can apply to TransferActive and TransferPause trigger.\n"
		"- **LevelLow** (Display string: 'Level Low'): Specifies that the trigger is considered valid as long as the level of the source signal is low. This can apply to TransferActive and TransferPause trigger.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferStatusSelector_get", _wrap_TransferControl_transferStatusSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which status of the transfer module to read.\n"
		"Selects which status of the transfer module to read.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Streaming** (Display string: 'Streaming'): Data blocks are transmitted when enough data is available.\n"
		"- **Paused** (Display string: 'Paused'): Data blocks transmission is suspended immediately.\n"
		"- **Stopping** (Display string: 'Stopping'): Data blocks transmission is stopping. The current block transmission will be completed and the transfer state will stop.\n"
		"- **Stopped** (Display string: 'Stopped'): Data blocks transmission is stopped.\n"
		"- **QueueOverflow** (Display string: 'Queue Overflow'): Data blocks queue is in overflow state.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferStatus_get", _wrap_TransferControl_transferStatus_get, METH_O, "\n"
		"A boolean property. Reads the status of the Transfer module signal selected by TransferStatusSelector.\n"
		"Reads the status of the Transfer module signal selected by TransferStatusSelector.\n"
		""},
	 { "TransferControl_transferComponentSelector_get", _wrap_TransferControl_transferComponentSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the color component for the control of the TransferStreamChannel feature.\n"
		"Selects the color component for the control of the TransferStreamChannel feature.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Red** (Display string: 'Red'): The TransferStreamChannel feature controls the index of the stream channel for the streaming of the red plane of the planar pixel formats.\n"
		"- **Green** (Display string: 'Green'): The TransferStreamChannel feature controls the index of the stream channel for the streaming of the green plane of the planar pixel formats.\n"
		"- **Blue** (Display string: 'Blue'): The TransferStreamChannel feature controls the index of the stream channel for the streaming of blue plane of the planar pixel formats.\n"
		"- **All** (Display string: 'All'): The TransferStreamChannel feature controls the index of the stream channel for the streaming of all the planes of the planar pixel formats simultaneously or non planar pixel formats.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransferControl_transferStreamChannel_get", _wrap_TransferControl_transferStreamChannel_get, METH_O, "\n"
		"An integer property. Selects the streaming channel that will be used to transfer the selected stream of data.\n"
		"Selects the streaming channel that will be used to transfer the selected stream of data. In general, this feature can be omitted and the default streaming channel will be used.\n"
		""},
	 { "delete_TransferControl", _wrap_delete_TransferControl, METH_O, NULL},
	 { "TransferControl_swigregister", TransferControl_swigregister, METH_O, NULL},
	 { "TransferControl_swiginit", TransferControl_swiginit, METH_VARARGS, NULL},
	 { "new_Scan3dControl", _wrap_new_Scan3dControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::Scan3dControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "Scan3dControl_scan3dExtractionSelector_get", _wrap_Scan3dControl_scan3dExtractionSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the 3D Extraction processing module to control (if multiple ones are present).\n"
		"Selects the 3D Extraction processing module to control (if multiple ones are present).\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Scan3dExtraction0** (Display string: 'Scan 3d Extraction 0'): Selects Scan3d Extraction module 0.\n"
		"- **Scan3dExtraction1** (Display string: 'Scan 3d Extraction 1'): Selects Scan3d Extraction module 1.\n"
		"- **Scan3dExtraction2** (Display string: 'Scan 3d Extraction 2'): Selects Scan3d Extraction module 2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dExtractionSource_get", _wrap_Scan3dControl_scan3dExtractionSource_get, METH_O, "\n"
		"An enumerated integer property. Selects the sensor's data source region for 3D Extraction module.\n"
		"Selects the sensor's data source region for 3D Extraction module.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Region0** (Display string: 'Region 0'): Data come from Sensor's Region0.\n"
		"- **Region1** (Display string: 'Region 1'): Data come from Sensor's Region1.\n"
		"- **Region2** (Display string: 'Region 2'): Data come from Sensor's Region2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dExtractionMethod_get", _wrap_Scan3dControl_scan3dExtractionMethod_get, METH_O, "\n"
		"An enumerated integer property. Selects the method for extracting 3D from the input sensor data.\n"
		"Selects the method for extracting 3D from the input sensor data.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Default** (Display string: 'Default'): Default range extraction method for the device.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dDistanceUnit_get", _wrap_Scan3dControl_scan3dDistanceUnit_get, METH_O, "\n"
		"An enumerated integer property. Specifies the unit used when delivering (calibrated) distance data.\n"
		"Specifies the unit used when delivering (calibrated) distance data.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Millimeter** (Display string: 'Millimeter'): Distance values are in millimeter units (default).\n"
		"- **Meter** (Display string: 'Meter'): Distance values are in meter units.\n"
		"- **Inch** (Display string: 'Inch'): Distance values are in inch units.\n"
		"- **Pixel** (Display string: 'Pixel'): Distance values are given as a multiple of the size of a pixel.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dCoordinateSystem_get", _wrap_Scan3dControl_scan3dCoordinateSystem_get, METH_O, "\n"
		"An enumerated integer property. Specifies the Coordinate system to use for the device.\n"
		"Specifies the Coordinate system to use for the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Cartesian** (Display string: 'Cartesian'): Default value. 3-axis orthogonal, right-hand X-Y-Z.\n"
		"- **Spherical** (Display string: 'Spherical'): A Theta-Phi-Rho coordinate system.\n"
		"- **Cylindrical** (Display string: 'Cylindrical'): A Theta-Y-Rho coordinate system.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dOutputMode_get", _wrap_Scan3dControl_scan3dOutputMode_get, METH_O, "\n"
		"An enumerated integer property. Controls the Calibration and data organization of the device and  the coordinates transmitted.\n"
		"Controls the Calibration and data organization of the device and  the coordinates transmitted.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **UncalibratedC** (Display string: 'Uncalibrated C'): Uncalibrated 2.5D Depth map. The distance data does not represent a physical unit and may be non-linear. The data is a 2.5D range map only.\n"
		"- **CalibratedABC_Grid** (Display string: 'Calibrated ABC Grid'): 3 Coordinates in grid organization. The full 3 coordinate data with the grid array organization from the sensor kept.\n"
		"- **CalibratedABC_PointCloud** (Display string: 'Calibrated ABC Point Cloud'): 3 Coordinates without organization. The full 3 coordinate data without any organization of data points. Typically only valid points transmitted giving varying image size.\n"
		"- **CalibratedAC** (Display string: 'Calibrated AC'): 2 Coordinates with fixed B sampling. The data is sent as a A and C coordinates (X,Z or Theta,Rho). The B (Y) axis uses the scale and offset parameters for the B axis.\n"
		"- **CalibratedAC_Linescan** (Display string: 'Calibrated AC Linescan'): 2 Coordinates with varying sampling. The data is sent as a A and C coordinates (X,Z or Theta,Rho). The B (Y) axis comes from the encoder chunk value.\n"
		"- **CalibratedC** (Display string: 'Calibrated C'): Calibrated 2.5D Depth map. The distance data is expressed in the chosen distance unit. The data is a 2.5D range map. No information on X-Y axes available.\n"
		"- **CalibratedC_Linescan** (Display string: 'Calibrated C Linescan'): Depth Map with varying B sampling. The distance data is expressed in the chosen distance unit. The data is a 2.5D range map. The B (Y) axis comes from the encoder chunk value.\n"
		"- **RectifiedC** (Display string: 'Rectified C'): Rectified 2.5D Depth map. The distance data has been rectified to a uniform sampling pattern in the X and Y direction. The data is a 2.5D range map only. If a complete 3D point cloud is rectified but transmitted as explicit coordinates it should be transmitted as one of the 'CalibratedABC' formats.\n"
		"- **RectifiedC_Linescan** (Display string: 'Rectified C Linescan'): Rectified 2.5D Depth map with varying B sampling. The data is sent as rectified 1D profiles using Coord3D_C pixels. The B (Y) axis comes from the encoder chunk value.\n"
		"- **DisparityC** (Display string: 'Disparity C'): Disparity 2.5D Depth map. The distance is inversely proportional to the pixel (disparity) value.\n"
		"- **DisparityC_Linescan** (Display string: 'Disparity C Linescan'): Disparity 2.5D Depth map with varying B sampling. The distance is inversely proportional to the pixel (disparity) value. The B (Y) axis comes from the encoder chunk value.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dCoordinateSystemReference_get", _wrap_Scan3dControl_scan3dCoordinateSystemReference_get, METH_O, "\n"
		"An enumerated integer property. Defines coordinate system reference location.\n"
		"Defines coordinate system reference location.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Anchor** (Display string: 'Anchor'): Default value. Original fixed reference. The coordinate system fixed relative the camera reference point marker is used.\n"
		"- **Transformed** (Display string: 'Transformed'): Transformed reference system. The transformed coordinate system is used according to the definition in the rotation and translation matrices.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dCoordinateSelector_get", _wrap_Scan3dControl_scan3dCoordinateSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the individual coordinates in the vectors for 3D information/transformation.\n"
		"Selects the individual coordinates in the vectors for 3D information/transformation.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **CoordinateA** (Display string: 'Coordinate A'): The first (X or Theta) coordinate\n"
		"- **CoordinateB** (Display string: 'Coordinate B'): The second (Y or Phi) coordinate\n"
		"- **CoordinateC** (Display string: 'Coordinate C'): The third (Z or Rho) coordinate.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dCoordinateScale_get", _wrap_Scan3dControl_scan3dCoordinateScale_get, METH_O, "\n"
		"A floating point property. Scale factor when transforming a pixel from relative coordinates to world coordinates.\n"
		"Scale factor when transforming a pixel from relative coordinates to world coordinates.\n"
		""},
	 { "Scan3dControl_scan3dCoordinateOffset_get", _wrap_Scan3dControl_scan3dCoordinateOffset_get, METH_O, "\n"
		"A floating point property. Offset when transforming a pixel from relative coordinates to world coordinates.\n"
		"Offset when transforming a pixel from relative coordinates to world coordinates.\n"
		""},
	 { "Scan3dControl_scan3dInvalidDataFlag_get", _wrap_Scan3dControl_scan3dInvalidDataFlag_get, METH_O, "\n"
		"A boolean property. Enables the definition of a non-valid flag value in the data stream.\n"
		"Enables the definition of a non-valid flag value in the data stream. Note that the confidence output is an alternate recommended way to identify non-valid pixels. Using a Scan3dInvalidDataValue may give processing penalties due to special handling.\n"
		""},
	 { "Scan3dControl_scan3dInvalidDataValue_get", _wrap_Scan3dControl_scan3dInvalidDataValue_get, METH_O, "\n"
		"A floating point property. Value which identifies a non-valid pixel if Scan3dInvalidDataFlag is enabled.\n"
		"Value which identifies a non-valid pixel if Scan3dInvalidDataFlag is enabled.\n"
		""},
	 { "Scan3dControl_scan3dAxisMin_get", _wrap_Scan3dControl_scan3dAxisMin_get, METH_O, "\n"
		"A floating point property. Minimum valid transmitted coordinate value of the selected Axis.\n"
		"Minimum valid transmitted coordinate value of the selected Axis.\n"
		""},
	 { "Scan3dControl_scan3dAxisMax_get", _wrap_Scan3dControl_scan3dAxisMax_get, METH_O, "\n"
		"A floating point property. Maximum valid transmitted coordinate value of the selected Axis.\n"
		"Maximum valid transmitted coordinate value of the selected Axis.\n"
		""},
	 { "Scan3dControl_scan3dCoordinateTransformSelector_get", _wrap_Scan3dControl_scan3dCoordinateTransformSelector_get, METH_O, "\n"
		"An enumerated integer property. Sets the index to read/write a coordinate transform value.\n"
		"Sets the index to read/write a coordinate transform value.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RotationX** (Display string: 'Rotation X'): Rotation around X axis.\n"
		"- **RotationY** (Display string: 'Rotation Y'): Rotation around Y axis.\n"
		"- **RotationZ** (Display string: 'Rotation Z'): Rotation around Z axis.\n"
		"- **TranslationX** (Display string: 'Translation X'): Translation along X axis.\n"
		"- **TranslationY** (Display string: 'Translation Y'): Translation along Y axis.\n"
		"- **TranslationZ** (Display string: 'Translation Z'): Translation along Z axis.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dTransformValue_get", _wrap_Scan3dControl_scan3dTransformValue_get, METH_O, "\n"
		"A floating point property. Specifies the transform value selected.\n"
		"Specifies the transform value selected. For translations (Scan3dCoordinateTransformSelector = TranslationX/Y/Z) it is expressed in the distance unit of the system, for rotations (Scan3dCoordinateTransformSelector =RotationX/Y/Z) in degrees.\n"
		""},
	 { "Scan3dControl_scan3dCoordinateReferenceSelector_get", _wrap_Scan3dControl_scan3dCoordinateReferenceSelector_get, METH_O, "\n"
		"An enumerated integer property. Sets the index to read a coordinate system reference value defining the transform of a point from the current (Anchor or Transformed) system to the reference system.\n"
		"Sets the index to read a coordinate system reference value defining the transform of a point from the current (Anchor or Transformed) system to the reference system.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RotationX** (Display string: 'Rotation X'): Rotation around X axis.\n"
		"- **RotationY** (Display string: 'Rotation Y'): Rotation around Y axis.\n"
		"- **RotationZ** (Display string: 'Rotation Z'): Rotation around Z axis.\n"
		"- **TranslationX** (Display string: 'Translation X'): X axis translation.\n"
		"- **TranslationY** (Display string: 'Translation Y'): Y axis translation.\n"
		"- **TranslationZ** (Display string: 'Translation Z'): Z axis translation.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "Scan3dControl_scan3dCoordinateReferenceValue_get", _wrap_Scan3dControl_scan3dCoordinateReferenceValue_get, METH_O, "\n"
		"A floating point property. Returns the reference value selected.\n"
		"Returns the reference value selected. Reads the value of a rotation or translation value for the current (Anchor or Transformed) coordinate system transformation to the Reference system.\n"
		""},
	 { "Scan3dControl_scan3dFocalLength_get", _wrap_Scan3dControl_scan3dFocalLength_get, METH_O, "\n"
		"A floating point property. Returns the focal length of the camera in pixel.\n"
		"Returns the focal length of the camera in pixel. The focal length depends on the selected region. The value of this feature takes into account horizontal binning, decimation, or any other function changing the image resolution.\n"
		""},
	 { "Scan3dControl_scan3dBaseline_get", _wrap_Scan3dControl_scan3dBaseline_get, METH_O, "\n"
		"A floating point property. Returns the baseline as the physical distance of two cameras in a stereo camera setup.\n"
		"Returns the baseline as the physical distance of two cameras in a stereo camera setup. The value of this feature can be used for 3D reconstruction from disparity images. In this case, the unit of the 3D coordinates corresponds to the unit of the baseline.\n"
		""},
	 { "Scan3dControl_scan3dPrincipalPointU_get", _wrap_Scan3dControl_scan3dPrincipalPointU_get, METH_O, "\n"
		"A floating point property. Returns the value of the horizontal position of the principal point, relative to the region origin, i.e.\n"
		"Returns the value of the horizontal position of the principal point, relative to the region origin, i.e. OffsetX. The value of this feature takes into account horizontal binning, decimation, or any other function changing the image resolution.\n"
		""},
	 { "Scan3dControl_scan3dPrincipalPointV_get", _wrap_Scan3dControl_scan3dPrincipalPointV_get, METH_O, "\n"
		"A floating point property. Returns the value of the vertical position of the principal point, relative to the region origin, i.e.\n"
		"Returns the value of the vertical position of the principal point, relative to the region origin, i.e. OffsetY. The value of this feature takes into account vertical binning, decimation, or any other function changing the image resolution.\n"
		""},
	 { "delete_Scan3dControl", _wrap_delete_Scan3dControl, METH_O, NULL},
	 { "Scan3dControl_swigregister", Scan3dControl_swigregister, METH_O, NULL},
	 { "Scan3dControl_swiginit", Scan3dControl_swiginit, METH_VARARGS, NULL},
	 { "new_DepthControl", _wrap_new_DepthControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::DepthControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "DepthControl_depthQuality_get", _wrap_DepthControl_depthQuality_get, METH_O, "\n"
		"An enumerated integer property. Depth image quality (resolution).\n"
		"Depth image quality (resolution).\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Low** (Display string: 'Low'): Low depth image quality.\n"
		"- **Medium** (Display string: 'Medium'): Medium depth image quality.\n"
		"- **High** (Display string: 'High'): High depth image quality.\n"
		"- **Full** (Display string: 'Full'): Full resolution depth image.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DepthControl_depthFill_get", _wrap_DepthControl_depthFill_get, METH_O, "\n"
		"An integer property. Higher numbers fill gaps with measurements with potentially higher errors.\n"
		"Higher numbers fill gaps with measurements with potentially higher errors.\n"
		""},
	 { "DepthControl_depthSeg_get", _wrap_DepthControl_depthSeg_get, METH_O, "\n"
		"An integer property. Maximum size of isolated disparity regions that will be invalidated, related to full resolution.\n"
		"Maximum size of isolated disparity regions that will be invalidated, related to full resolution.\n"
		""},
	 { "DepthControl_depthMinConf_get", _wrap_DepthControl_depthMinConf_get, METH_O, "\n"
		"A floating point property. Minimal confidence. All disparities with lower confidence will be set to invalid.\n"
		"Minimal confidence. All disparities with lower confidence will be set to invalid.\n"
		""},
	 { "DepthControl_depthMinDepth_get", _wrap_DepthControl_depthMinDepth_get, METH_O, "\n"
		"A floating point property. Minimum depth in meter. All disparities with lower depth will be set to invalid.\n"
		"Minimum depth in meter. All disparities with lower depth will be set to invalid.\n"
		""},
	 { "DepthControl_depthMaxDepth_get", _wrap_DepthControl_depthMaxDepth_get, METH_O, "\n"
		"A floating point property. Maximum depth in meter. All disparities with higher depth will be set to invalid.\n"
		"Maximum depth in meter. All disparities with higher depth will be set to invalid.\n"
		""},
	 { "DepthControl_depthMaxDepthErr_get", _wrap_DepthControl_depthMaxDepthErr_get, METH_O, "\n"
		"A floating point property. Maximum depth error in meter. All disparities with a higher depth error will be set to invalid.\n"
		"Maximum depth error in meter. All disparities with a higher depth error will be set to invalid.\n"
		""},
	 { "DepthControl_depthAcquisitionMode_get", _wrap_DepthControl_depthAcquisitionMode_get, METH_O, "\n"
		"An enumerated integer property. Depth acquisition mode\n"
		"Depth acquisition mode\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **SingleFrame** (Display string: 'Single Frame'): This enumeration value sets the camera's depth acquisition mode to single frame.\n"
		"- **SingleFrameOut1** (Display string: 'Single Frame Out 1'): This enumeration value sets the camera's depth acquisition mode to single frame and toggles the Out1 mode between Low and ExposureAlternateActive as needed.\n"
		"- **Continuous** (Display string: 'Continuous'): This enumeration value sets the camera's depth acquisition mode to continuous.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DepthControl_depthAcquisitionTrigger_get", _wrap_DepthControl_depthAcquisitionTrigger_get, METH_O, "\n"
		"A method object. Triggers a depth acquisition of the device.\n"
		"Triggers a depth acquisition of the device. Only relevant in SingleFrame(Out1) DepthAcquisitionMode.\n"
		""},
	 { "DepthControl_depthSmooth_get", _wrap_DepthControl_depthSmooth_get, METH_O, "\n"
		"A boolean property. Enables smoothing of the disparity image.\n"
		"Enables smoothing of the disparity image.\n"
		""},
	 { "DepthControl_depthStaticScene_get", _wrap_DepthControl_depthStaticScene_get, METH_O, "\n"
		"A boolean property. Enables accumulation of multiple images for noise reduction in static scenes.\n"
		"Enables accumulation of multiple images for noise reduction in static scenes. Only applied to High and Full quality.\n"
		""},
	 { "DepthControl_depthDoubleShot_get", _wrap_DepthControl_depthDoubleShot_get, METH_O, "\n"
		"A boolean property. Enables combination of disaprity images from two stereo pairs.\n"
		"Enables combination of disaprity images from two stereo pairs.\n"
		""},
	 { "DepthControl_depthExposureAdaptTimeout_get", _wrap_DepthControl_depthExposureAdaptTimeout_get, METH_O, "\n"
		"A floating point property. Maximum time in seconds to wait after triggering in SingleFrame modes until auto exposure has finished adjustments.\n"
		"Maximum time in seconds to wait after triggering in SingleFrame modes until auto exposure has finished adjustments.\n"
		""},
	 { "delete_DepthControl", _wrap_delete_DepthControl, METH_O, NULL},
	 { "DepthControl_swigregister", DepthControl_swigregister, METH_O, NULL},
	 { "DepthControl_swiginit", DepthControl_swiginit, METH_VARARGS, NULL},
	 { "new_LightControl", _wrap_new_LightControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::LightControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "LightControl_lightControllerSelector_get", _wrap_LightControl_lightControllerSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the Light Controller to configure.\n"
		"Selects the Light Controller to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **LightController0** (Display string: 'Light Controller 0'): Light Controller 0\n"
		"- **LightController1** (Display string: 'Light Controller 1'): Light Controller 1\n"
		"- **LightController2** (Display string: 'Light Controller 2'): Light Controller 2\n"
		"- **LightController3** (Display string: 'Light Controller 3'): Light Controller 3\n"
		"- **LightController4** (Display string: 'Light Controller 4'): Light Controller 4\n"
		"- **LightController5** (Display string: 'Light Controller 5'): Light Controller 5\n"
		"- **LightController6** (Display string: 'Light Controller 6'): Light Controller 6\n"
		"- **LightController7** (Display string: 'Light Controller 7'): Light Controller 7\n"
		"- **LightController8** (Display string: 'Light Controller 8'): Light Controller 8\n"
		"- **LightController9** (Display string: 'Light Controller 9'): Light Controller 9\n"
		"- **LightController10** (Display string: 'Light Controller 10'): Light Controller 10\n"
		"- **LightController11** (Display string: 'Light Controller 11'): Light Controller 11\n"
		"- **LightController12** (Display string: 'Light Controller 12'): Light Controller 12\n"
		"- **LightController13** (Display string: 'Light Controller 13'): Light Controller 13\n"
		"- **LightController14** (Display string: 'Light Controller 14'): Light Controller 14\n"
		"- **LightController15** (Display string: 'Light Controller 15'): Light Controller 15\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "LightControl_lightControllerSource_get", _wrap_LightControl_lightControllerSource_get, METH_O, "\n"
		"An enumerated integer property. Selects the input source signal of the Light Controller.\n"
		"Selects the input source signal of the Light Controller.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Counter0** (Display string: 'Counter 0'): Counter 0\n"
		"- **Counter1** (Display string: 'Counter 1'): Counter 1\n"
		"- **Counter2** (Display string: 'Counter 2'): Counter 2\n"
		"- **Counter3** (Display string: 'Counter 3'): Counter 3\n"
		"- **Counter4** (Display string: 'Counter 4'): Counter 4\n"
		"- **Counter5** (Display string: 'Counter 5'): Counter 5\n"
		"- **Counter6** (Display string: 'Counter 6'): Counter 6\n"
		"- **Counter7** (Display string: 'Counter 7'): Counter 7\n"
		"- **Counter8** (Display string: 'Counter 8'): Counter 8\n"
		"- **Counter9** (Display string: 'Counter 9'): Counter 9\n"
		"- **Counter10** (Display string: 'Counter 10'): Counter 10\n"
		"- **Counter11** (Display string: 'Counter 11'): Counter 11\n"
		"- **Counter12** (Display string: 'Counter 12'): Counter 12\n"
		"- **Counter13** (Display string: 'Counter 13'): Counter 13\n"
		"- **Counter14** (Display string: 'Counter 14'): Counter 14\n"
		"- **Counter15** (Display string: 'Counter 15'): Counter 15\n"
		"- **Line0** (Display string: 'Line 0'): Line 0\n"
		"- **Line1** (Display string: 'Line 1'): Line 1\n"
		"- **Line2** (Display string: 'Line 2'): Line 2\n"
		"- **Line3** (Display string: 'Line 3'): Line 3\n"
		"- **Line4** (Display string: 'Line 4'): Line 4\n"
		"- **Line5** (Display string: 'Line 5'): Line 5\n"
		"- **Line6** (Display string: 'Line 6'): Line 6\n"
		"- **Line7** (Display string: 'Line 7'): Line 7\n"
		"- **Line8** (Display string: 'Line 8'): Line 8\n"
		"- **Line9** (Display string: 'Line 9'): Line 9\n"
		"- **Line10** (Display string: 'Line 10'): Line 10\n"
		"- **Line11** (Display string: 'Line 11'): Line 11\n"
		"- **Line12** (Display string: 'Line 12'): Line 12\n"
		"- **Line13** (Display string: 'Line 13'): Line 13\n"
		"- **Line14** (Display string: 'Line 14'): Line 14\n"
		"- **Line15** (Display string: 'Line 15'): Line 15\n"
		"- **Timer0** (Display string: 'Timer 0'): Timer 0\n"
		"- **Timer1** (Display string: 'Timer 1'): Timer 1\n"
		"- **Timer2** (Display string: 'Timer 2'): Timer 2\n"
		"- **Timer3** (Display string: 'Timer 3'): Timer 3\n"
		"- **Timer4** (Display string: 'Timer 4'): Timer 4\n"
		"- **Timer5** (Display string: 'Timer 5'): Timer 5\n"
		"- **Timer6** (Display string: 'Timer 6'): Timer 6\n"
		"- **Timer7** (Display string: 'Timer 7'): Timer 7\n"
		"- **Timer8** (Display string: 'Timer 8'): Timer 8\n"
		"- **Timer9** (Display string: 'Timer 9'): Timer 9\n"
		"- **Timer10** (Display string: 'Timer 10'): Timer 10\n"
		"- **Timer11** (Display string: 'Timer 11'): Timer 11\n"
		"- **Timer12** (Display string: 'Timer 12'): Timer 12\n"
		"- **Timer13** (Display string: 'Timer 13'): Timer 13\n"
		"- **Timer14** (Display string: 'Timer 14'): Timer 14\n"
		"- **Timer15** (Display string: 'Timer 15'): Timer 15\n"
		"- **UserOutput0** (Display string: 'User Output 0'): User Output 0\n"
		"- **UserOutput1** (Display string: 'User Output 1'): User Output 1\n"
		"- **UserOutput2** (Display string: 'User Output 2'): User Output 2\n"
		"- **UserOutput3** (Display string: 'User Output 3'): User Output 3\n"
		"- **UserOutput4** (Display string: 'User Output 4'): User Output 4\n"
		"- **UserOutput5** (Display string: 'User Output 5'): User Output 5\n"
		"- **UserOutput6** (Display string: 'User Output 6'): User Output 6\n"
		"- **UserOutput7** (Display string: 'User Output 7'): User Output 7\n"
		"- **UserOutput8** (Display string: 'User Output 8'): User Output 8\n"
		"- **UserOutput9** (Display string: 'User Output 9'): User Output 9\n"
		"- **UserOutput10** (Display string: 'User Output 10'): User Output 10\n"
		"- **UserOutput11** (Display string: 'User Output 11'): User Output 11\n"
		"- **UserOutput12** (Display string: 'User Output 12'): User Output 12\n"
		"- **UserOutput13** (Display string: 'User Output 13'): User Output 13\n"
		"- **UserOutput14** (Display string: 'User Output 14'): User Output 14\n"
		"- **UserOutput15** (Display string: 'User Output 15'): User Output 15\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "LightControl_lightCurrentRating_get", _wrap_LightControl_lightCurrentRating_get, METH_O, "\n"
		"A floating point property. Set the current rating of the lighting output.\n"
		"Set the current rating of the lighting output.\n"
		""},
	 { "LightControl_lightVoltageRating_get", _wrap_LightControl_lightVoltageRating_get, METH_O, "\n"
		"A floating point property. Set the voltage rating of the lighting output.\n"
		"Set the voltage rating of the lighting output.\n"
		""},
	 { "LightControl_lightBrightness_get", _wrap_LightControl_lightBrightness_get, METH_O, "\n"
		"A floating point property. Set the brightness of the lighting output in percent.\n"
		"Set the brightness of the lighting output in percent. Can be greater than 100% for short overdrive period.\n"
		""},
	 { "LightControl_lightConnectionStatus_get", _wrap_LightControl_lightConnectionStatus_get, METH_O, "\n"
		"An enumerated integer property. Status of a light connected to the controller's output Line.\n"
		"Status of a light connected to the controller's output Line.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Sensing** (Display string: 'Sensing'): Sensing\n"
		"- **Ready** (Display string: 'Ready'): Ready\n"
		"- **NoConnect** (Display string: 'No Connect'): No Connect\n"
		"- **Error** (Display string: 'Error'): Error\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "LightControl_lightCurrentMeasured_get", _wrap_LightControl_lightCurrentMeasured_get, METH_O, "\n"
		"A floating point property. The measured current applied to the lighting.\n"
		"The measured current applied to the lighting.\n"
		""},
	 { "LightControl_lightVoltageMeasured_get", _wrap_LightControl_lightVoltageMeasured_get, METH_O, "\n"
		"A floating point property. The measured voltage applied to the lighting.\n"
		"The measured voltage applied to the lighting.\n"
		""},
	 { "delete_LightControl", _wrap_delete_LightControl, METH_O, NULL},
	 { "LightControl_swigregister", LightControl_swigregister, METH_O, NULL},
	 { "LightControl_swiginit", LightControl_swiginit, METH_VARARGS, NULL},
	 { "new_OpticControl", _wrap_new_OpticControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::OpticControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "OpticControl_opticControllerSelector_get", _wrap_OpticControl_opticControllerSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which optic controller to configure.\n"
		"Selects which optic controller to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **OpticController0** (Display string: 'Optic Controller 0'): Selects Optic Controller 0.\n"
		"- **OpticController1** (Display string: 'Optic Controller 1'): Selects Optic Controller 1.\n"
		"- **OpticController2** (Display string: 'Optic Controller 2'): Selects Optic Controller 2.\n"
		"- **OpticController3** (Display string: 'Optic Controller 3'): Selects Optic Controller 3.\n"
		"- **OpticController4** (Display string: 'Optic Controller 4'): Selects Optic Controller 4.\n"
		"- **OpticController5** (Display string: 'Optic Controller 5'): Selects Optic Controller 5.\n"
		"- **OpticController6** (Display string: 'Optic Controller 6'): Selects Optic Controller 6.\n"
		"- **OpticController7** (Display string: 'Optic Controller 7'): Selects Optic Controller 7.\n"
		"- **OpticController8** (Display string: 'Optic Controller 8'): Selects Optic Controller 8.\n"
		"- **OpticController9** (Display string: 'Optic Controller 9'): Selects Optic Controller 9.\n"
		"- **OpticController10** (Display string: 'Optic Controller 10'): Selects Optic Controller 10.\n"
		"- **OpticController11** (Display string: 'Optic Controller 11'): Selects Optic Controller 11.\n"
		"- **OpticController12** (Display string: 'Optic Controller 12'): Selects Optic Controller 12.\n"
		"- **OpticController13** (Display string: 'Optic Controller 13'): Selects Optic Controller 13.\n"
		"- **OpticController14** (Display string: 'Optic Controller 14'): Selects Optic Controller 14.\n"
		"- **OpticController15** (Display string: 'Optic Controller 15'): Selects Optic Controller 15.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_opticControllerInitialize_get", _wrap_OpticControl_opticControllerInitialize_get, METH_O, "\n"
		"A method object. Initializes the optic controller and makes it ready for use.\n"
		"Initializes the optic controller and makes it ready for use.\n"
		""},
	 { "OpticControl_opticControllerDisconnect_get", _wrap_OpticControl_opticControllerDisconnect_get, METH_O, "\n"
		"A method object. Closes the optic controller connection and prepares it for removal.\n"
		"Closes the optic controller connection and prepares it for removal.\n"
		""},
	 { "OpticControl_opticControllerAbort_get", _wrap_OpticControl_opticControllerAbort_get, METH_O, "\n"
		"A method object. Aborts the current command or feature access.\n"
		"Aborts the current command or feature access. This will end the process without completing it or having reached the desired end position or value. If no command or feature access is in progress, the command is ignored.\n"
		""},
	 { "OpticControl_opticControllerStatus_get", _wrap_OpticControl_opticControllerStatus_get, METH_O, "\n"
		"An enumerated integer property. Reads the status of the optic controller.\n"
		"Reads the status of the optic controller.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NotConnected** (Display string: 'Not Connected'): The optic controller is physically not connected.\n"
		"- **NotInitialized** (Display string: 'Not Initialized'): The optic controller is not initialized.\n"
		"- **NotSupported** (Display string: 'Not Supported'): The optic controller is physically connected but not supported.\n"
		"- **Busy** (Display string: 'Busy'): The optic controller executes a feature access/command.\n"
		"- **Ready** (Display string: 'Ready'): The optic controller is ready to use.\n"
		"- **Error** (Display string: 'Error'): The optic controller encountered an error.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_opticControllerVendorName_get", _wrap_OpticControl_opticControllerVendorName_get, METH_O, "\n"
		"A string property. Name of the manufacturer of the optic controller.\n"
		"Name of the manufacturer of the optic controller.\n"
		""},
	 { "OpticControl_opticControllerFamilyName_get", _wrap_OpticControl_opticControllerFamilyName_get, METH_O, "\n"
		"A string property. Name of the device family of the optic controller.\n"
		"Name of the device family of the optic controller.\n"
		""},
	 { "OpticControl_opticControllerModelName_get", _wrap_OpticControl_opticControllerModelName_get, METH_O, "\n"
		"A string property. Model name of the optic controller.\n"
		"Model name of the optic controller.\n"
		""},
	 { "OpticControl_opticControllerSerialNumber_get", _wrap_OpticControl_opticControllerSerialNumber_get, METH_O, "\n"
		"A string property. Serial number of the optic controller.\n"
		"Serial number of the optic controller.\n"
		""},
	 { "OpticControl_opticControllerVersion_get", _wrap_OpticControl_opticControllerVersion_get, METH_O, "\n"
		"A string property. Version of the optic controller.\n"
		"Version of the optic controller.\n"
		""},
	 { "OpticControl_opticControllerFirmwareVersion_get", _wrap_OpticControl_opticControllerFirmwareVersion_get, METH_O, "\n"
		"A string property. Version of the firmware in the optic controller.\n"
		"Version of the firmware in the optic controller.\n"
		""},
	 { "OpticControl_opticControllerTemperature_get", _wrap_OpticControl_opticControllerTemperature_get, METH_O, "\n"
		"A floating point property. Temperature of the optic controller in degrees Celsius (C).\n"
		"Temperature of the optic controller in degrees Celsius (C).\n"
		""},
	 { "OpticControl_apertureInitialize_get", _wrap_OpticControl_apertureInitialize_get, METH_O, "\n"
		"A method object. Initializes the aperture and makes it ready for use.\n"
		"Initializes the aperture and makes it ready for use. The aperture position after initialization is implementation dependent. This feature is only implemented if an additional initialization is required after OpticControllerInitialize.\n"
		""},
	 { "OpticControl_apertureStatus_get", _wrap_OpticControl_apertureStatus_get, METH_O, "\n"
		"An enumerated integer property. Reads the status of the aperture.\n"
		"Reads the status of the aperture.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NotConnected** (Display string: 'Not Connected'): The aperture controller is physically not connected.\n"
		"- **NotInitialized** (Display string: 'Not Initialized'): The aperture controller is not initialized.\n"
		"- **NotSupported** (Display string: 'Not Supported'): The aperture controller is physically connected but not supported.\n"
		"- **Busy** (Display string: 'Busy'): The aperture controller executes a feature access/command.\n"
		"- **Ready** (Display string: 'Ready'): The aperture controller is ready to use.\n"
		"- **Error** (Display string: 'Error'): The aperture controller encountered an error.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_aperture_get", _wrap_OpticControl_aperture_get, METH_O, "\n"
		"A floating point property. Sets the aperture (also called iris, f-number, f-stop or f/#) of the lens.\n"
		"Sets the aperture (also called iris, f-number, f-stop or f/#) of the lens. The lower the f/# the more light goes through the lens (the 'faster' the lens) and the smaller the depth of field.\n"
		""},
	 { "OpticControl_apertureStepper_get", _wrap_OpticControl_apertureStepper_get, METH_O, "\n"
		"An integer property. ApertureStepper controls the stepper value of the aperture.\n"
		"ApertureStepper controls the stepper value of the aperture. 0 is the maximum opening.\n"
		""},
	 { "OpticControl_numericalAperture_get", _wrap_OpticControl_numericalAperture_get, METH_O, "\n"
		"A floating point property. Sets the numerical aperture of a lens.\n"
		"Sets the numerical aperture of a lens. It is inversely proportional to the f/#.\n"
		""},
	 { "OpticControl_focusInitialize_get", _wrap_OpticControl_focusInitialize_get, METH_O, "\n"
		"A method object. Initializes the focus and makes it ready for use.\n"
		"Initializes the focus and makes it ready for use. The focus position after initialization is implementation dependent. This feature is only implemented if an additional initialization is required after OpticControllerInitialize.\n"
		""},
	 { "OpticControl_focusStatus_get", _wrap_OpticControl_focusStatus_get, METH_O, "\n"
		"An enumerated integer property. Reads the status of the focus.\n"
		"Reads the status of the focus.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NotConnected** (Display string: 'Not Connected'): The focus controller is physically not connected.\n"
		"- **NotInitialized** (Display string: 'Not Initialized'): The focus controller is not initialized.\n"
		"- **NotSupported** (Display string: 'Not Supported'): The focus controller is physically connected but not supported.\n"
		"- **Busy** (Display string: 'Busy'): The focus controller executes a feature access/command.\n"
		"- **Ready** (Display string: 'Ready'): The focus controller is ready to use.\n"
		"- **Error** (Display string: 'Error'): The focus controller encountered an error.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_focusStepper_get", _wrap_OpticControl_focusStepper_get, METH_O, "\n"
		"An integer property. FocusStepper controls the stepper value of the focus.\n"
		"FocusStepper controls the stepper value of the focus. E.g. ObjectSensorDistance or FocalPower. 0 is the closest focus.\n"
		""},
	 { "OpticControl_focusAutoMode_get", _wrap_OpticControl_focusAutoMode_get, METH_O, "\n"
		"An enumerated integer property. Sets automatic focus mode.\n"
		"Sets automatic focus mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **DistanceBased** (Display string: 'Distance Based'): The OpticController has a built-in distance sensor and computes the focus based on the detected distance (open loop).\n"
		"- **ImageBased** (Display string: 'Image Based'): The OpticController evaluates the image for closed loop control (closed loop).\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_focusAuto_get", _wrap_OpticControl_focusAuto_get, METH_O, "\n"
		"An enumerated integer property. Sets automatic focus.\n"
		"Sets automatic focus. If enabled, the optic device shall be set into a mode of operation, where the lens automatically finds the best possible focus.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The focus is set manually.\n"
		"- **Once** (Display string: 'Once'): The focus is adapted once by the device. Once it has converged, it returns to the Off state.\n"
		"- **Continuous** (Display string: 'Continuous'): The focus is constantly adapted by the device to maximize the dynamic range.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_focalPower_get", _wrap_OpticControl_focalPower_get, METH_O, "\n"
		"A floating point property. Sets the focal power (in diopters/dpt).\n"
		"Sets the focal power (in diopters/dpt). This is mostly used for liquid lenses and indicates how much a liquid lens focuses.\n"
		""},
	 { "OpticControl_objectSensorDistance_get", _wrap_OpticControl_objectSensorDistance_get, METH_O, "\n"
		"A floating point property. Distance from the image sensor surface to the object in millimeters (mm).\n"
		"Distance from the image sensor surface to the object in millimeters (mm).\n"
		""},
	 { "OpticControl_focalLengthInitialize_get", _wrap_OpticControl_focalLengthInitialize_get, METH_O, "\n"
		"A method object. Initializes the focal length and makes it ready for use.\n"
		"Initializes the focal length and makes it ready for use. The focal length position after initialization is implementation dependent. This feature is only implemented if an additional initialization is required after OpticControllerInitialize.\n"
		""},
	 { "OpticControl_focalLengthStatus_get", _wrap_OpticControl_focalLengthStatus_get, METH_O, "\n"
		"An enumerated integer property. Reads the status of the focal length.\n"
		"Reads the status of the focal length.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NotConnected** (Display string: 'Not Connected'): The focal length controller is physically not connected.\n"
		"- **NotInitialized** (Display string: 'Not Initialized'): The focal length controller is not initialized.\n"
		"- **NotSupported** (Display string: 'Not Supported'): The focal length controller is physically connected but not supported.\n"
		"- **Busy** (Display string: 'Busy'): The focal length controller executes a feature access/command.\n"
		"- **Ready** (Display string: 'Ready'): The focal length controller is ready to use.\n"
		"- **Error** (Display string: 'Error'): The focal length controller encountered an error.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_focalLength_get", _wrap_OpticControl_focalLength_get, METH_O, "\n"
		"A floating point property. Focal length in millimeters (mm).\n"
		"Focal length in millimeters (mm).\n"
		""},
	 { "OpticControl_focalLengthStepper_get", _wrap_OpticControl_focalLengthStepper_get, METH_O, "\n"
		"An integer property. FocalLengthStepper controls the stepper value of the focal length.\n"
		"FocalLengthStepper controls the stepper value of the focal length. 0 is the shortest focal length.\n"
		""},
	 { "OpticControl_shutterInitialize_get", _wrap_OpticControl_shutterInitialize_get, METH_O, "\n"
		"A method object. Initializes the shutter and makes it ready for use.\n"
		"Initializes the shutter and makes it ready for use. The shutter position after initialization is implementation dependent. This feature is only implemented if an additional initialization is required after OpticControllerInitialize.\n"
		""},
	 { "OpticControl_shutterStatus_get", _wrap_OpticControl_shutterStatus_get, METH_O, "\n"
		"An enumerated integer property. Reads the status of the shutter.\n"
		"Reads the status of the shutter.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NotConnected** (Display string: 'Not Connected'): The shutter controller is physically not connected.\n"
		"- **NotInitialized** (Display string: 'Not Initialized'): The shutter controller is not initialized.\n"
		"- **NotSupported** (Display string: 'Not Supported'): The shutter controller is physically connected but not supported.\n"
		"- **Busy** (Display string: 'Busy'): The shutter controller executes a feature access/command.\n"
		"- **Ready** (Display string: 'Ready'): The shutter controller is ready to use.\n"
		"- **Error** (Display string: 'Error'): The shutter controller encountered an error.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_shutter_get", _wrap_OpticControl_shutter_get, METH_O, "\n"
		"An integer property. Controls whether the shutter is opened or closed.\n"
		"Controls whether the shutter is opened or closed.\n"
		""},
	 { "OpticControl_filterInitialize_get", _wrap_OpticControl_filterInitialize_get, METH_O, "\n"
		"A method object. Initializes the filter and makes it ready for use.\n"
		"Initializes the filter and makes it ready for use. The filter position after initialization is implementation dependent. This feature is only implemented if an additional initialization is required after OpticControllerInitialize.\n"
		""},
	 { "OpticControl_filterStatus_get", _wrap_OpticControl_filterStatus_get, METH_O, "\n"
		"An enumerated integer property. Reads the status of the filter.\n"
		"Reads the status of the filter.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NotConnected** (Display string: 'Not Connected'): The filter controller is physically not connected.\n"
		"- **NotInitialized** (Display string: 'Not Initialized'): The filter controller is not initialized.\n"
		"- **NotSupported** (Display string: 'Not Supported'): The filter controller is physically connected but not supported.\n"
		"- **Busy** (Display string: 'Busy'): The filter controller executes a feature access/command.\n"
		"- **Ready** (Display string: 'Ready'): The filter controller is ready to use.\n"
		"- **Error** (Display string: 'Error'): The filter controller encountered an error.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_filter_get", _wrap_OpticControl_filter_get, METH_O, "\n"
		"An integer property. Filter positions in native number system.\n"
		"Filter positions in native number system. This is implementation dependent.\n"
		""},
	 { "OpticControl_stabilizationInitialize_get", _wrap_OpticControl_stabilizationInitialize_get, METH_O, "\n"
		"A method object. Initializes the stabilization and makes it ready for use.\n"
		"Initializes the stabilization and makes it ready for use. The stabilization state after initialization is implementation dependent. This feature is only implemented if an additional initialization is required after OpticControllerInitialize.\n"
		""},
	 { "OpticControl_stabilizationStatus_get", _wrap_OpticControl_stabilizationStatus_get, METH_O, "\n"
		"An enumerated integer property. Reads the status of the stabilization.\n"
		"Reads the status of the stabilization.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NotConnected** (Display string: 'Not Connected'): The stabilization controller is physically not connected.\n"
		"- **NotInitialized** (Display string: 'Not Initialized'): The stabilization controller is not initialized.\n"
		"- **NotSupported** (Display string: 'Not Supported'): The stabilization controller is physically connected but not supported.\n"
		"- **Busy** (Display string: 'Busy'): The stabilization controller executes a feature access/command.\n"
		"- **Ready** (Display string: 'Ready'): The stabilization controller is ready to use.\n"
		"- **Error** (Display string: 'Error'): The stabilization controller encountered an error.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_stabilization_get", _wrap_OpticControl_stabilization_get, METH_O, "\n"
		"An integer property. Control of image stabilization function build into the optic controller.\n"
		"Control of image stabilization function build into the optic controller.\n"
		""},
	 { "OpticControl_magnificationInitialize_get", _wrap_OpticControl_magnificationInitialize_get, METH_O, "\n"
		"A method object. Initializes the magnification and makes it ready for use.\n"
		"Initializes the magnification and makes it ready for use. The magnification position after initialization is implementation dependent. This feature is only implemented if an additional initialization is required after OpticControllerInitialize.\n"
		""},
	 { "OpticControl_magnificationStatus_get", _wrap_OpticControl_magnificationStatus_get, METH_O, "\n"
		"An enumerated integer property. Reads the status of the magnification.\n"
		"Reads the status of the magnification.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NotConnected** (Display string: 'Not Connected'): The magnification controller is physically not connected.\n"
		"- **NotInitialized** (Display string: 'Not Initialized'): The magnification controller is not initialized.\n"
		"- **NotSupported** (Display string: 'Not Supported'): The magnification controller is physically connected but not supported.\n"
		"- **Busy** (Display string: 'Busy'): The magnification controller executes a feature access/command.\n"
		"- **Ready** (Display string: 'Ready'): The magnification controller is ready to use.\n"
		"- **Error** (Display string: 'Error'): The magnification controller encountered an error.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "OpticControl_magnification_get", _wrap_OpticControl_magnification_get, METH_O, "\n"
		"A floating point property. Magnification of the lens, defined as ratio between apparent size of an image and its true size.\n"
		"Magnification of the lens, defined as ratio between apparent size of an image and its true size.\n"
		""},
	 { "OpticControl_magnificationStepper_get", _wrap_OpticControl_magnificationStepper_get, METH_O, "\n"
		"An integer property. MagnificationStepper controls the stepper value of the magnification.\n"
		"MagnificationStepper controls the stepper value of the magnification. 0 is the lowest magnification.\n"
		""},
	 { "delete_OpticControl", _wrap_delete_OpticControl, METH_O, NULL},
	 { "OpticControl_swigregister", OpticControl_swigregister, METH_O, NULL},
	 { "OpticControl_swiginit", OpticControl_swiginit, METH_VARARGS, NULL},
	 { "new_ChunkDataControl", _wrap_new_ChunkDataControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::ChunkDataControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "ChunkDataControl_chunkModeActive_get", _wrap_ChunkDataControl_chunkModeActive_get, METH_O, "\n"
		"A boolean property. Activates the inclusion of Chunk data in the transmitted payload.\n"
		"Activates the inclusion of Chunk data in the transmitted payload.\n"
		""},
	 { "ChunkDataControl_chunkXMLEnable_get", _wrap_ChunkDataControl_chunkXMLEnable_get, METH_O, "\n"
		"A boolean property. Activates the inclusion of the GenICam XML necessary to the chunk parser to decode all the Chunk data included in the transmitted payload.\n"
		"Activates the inclusion of the GenICam XML necessary to the chunk parser to decode all the Chunk data included in the transmitted payload.\n"
		""},
	 { "ChunkDataControl_chunkSelector_get", _wrap_ChunkDataControl_chunkSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Chunk to enable or control.\n"
		"Selects which Chunk to enable or control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Image** (Display string: 'Image'): Image\n"
		"- **OffsetX** (Display string: 'Offset X'): Offset X\n"
		"- **OffsetY** (Display string: 'Offset Y'): Offset Y\n"
		"- **Width** (Display string: 'Width'): Width\n"
		"- **Height** (Display string: 'Height'): Height\n"
		"- **PixelFormat** (Display string: 'Pixel Format'): Pixel Format\n"
		"- **PixelDynamicRangeMin** (Display string: 'Pixel Dynamic Range Min'): Pixel Dynamic Range Min\n"
		"- **PixelDynamicRangeMax** (Display string: 'Pixel Dynamic Range Max'): Pixel Dynamic Range Max\n"
		"- **BinningHorizontal** (Display string: 'Binning Horizontal'): Binning Horizontal\n"
		"- **BinningVertical** (Display string: 'Binning Vertical'): Binning Vertical\n"
		"- **DecimationHorizontal** (Display string: 'Decimation Horizontal'): Decimation Horizontal\n"
		"- **DecimationVertical** (Display string: 'Decimation Vertical'): Decimation Vertical\n"
		"- **ReverseX** (Display string: 'Reverse X'): Reverse X\n"
		"- **ReverseY** (Display string: 'Reverse Y'): Reverse Y\n"
		"- **Timestamp** (Display string: 'Timestamp'): Timestamp\n"
		"- **TimestampLatchValue** (Display string: 'Timestamp Latch Value'): Timestamp Latch Value\n"
		"- **LineStatusAll** (Display string: 'Line Status All'): Line Status All\n"
		"- **CounterValue** (Display string: 'Counter Value'): Counter Value\n"
		"- **TimerValue** (Display string: 'Timer Value'): Timer Value\n"
		"- **EncoderValue** (Display string: 'Encoder Value'): Encoder Value\n"
		"- **EncoderStatusValue** (Display string: 'Encoder Status Value'): Encoder Status Value\n"
		"- **ExposureTime** (Display string: 'Exposure Time'): Exposure Time\n"
		"- **Gain** (Display string: 'Gain'): Gain\n"
		"- **BlackLevel** (Display string: 'Black Level'): Black Level\n"
		"- **LinePitch** (Display string: 'Line Pitch'): Line Pitch\n"
		"- **FrameID** (Display string: 'Frame ID'): Frame ID\n"
		"- **SourceID** (Display string: 'Source ID'): Source ID\n"
		"- **SourceIDValue** (Display string: 'Source ID Value'): Source ID Value\n"
		"- **RegionID** (Display string: 'Region ID'): Region ID\n"
		"- **RegionIDValue** (Display string: 'Region ID Value'): Region ID Value\n"
		"- **ComponentID** (Display string: 'Component ID'): Component ID\n"
		"- **ComponentIDValue** (Display string: 'Component ID Value'): Component ID Value\n"
		"- **GroupIDValue** (Display string: 'Group ID Value'): Group ID Value\n"
		"- **TransferBlockID** (Display string: 'Transfer Block ID'): Transfer Block ID\n"
		"- **TransferStreamID** (Display string: 'Transfer Stream ID'): Transfer Stream ID\n"
		"- **TransferQueueCurrentBlockCount** (Display string: 'Transfer Queue Current Block Count'): Transfer Queue Current Block Count\n"
		"- **StreamChannelID** (Display string: 'Stream Channel ID'): Stream Channel ID\n"
		"- **SequencerSetActive** (Display string: 'Sequencer Set Active'): Sequencer Set Active\n"
		"- **Scan3dDistanceUnit** (Display string: 'Scan 3d Distance Unit'): Scan 3d Distance Unit\n"
		"- **Scan3dOutputMode** (Display string: 'Scan 3d Output Mode'): Scan 3d Output Mode\n"
		"- **Scan3dCoordinateSystem** (Display string: 'Scan 3d Coordinate System'): Scan 3d Coordinate System\n"
		"- **Scan3dCoordinateSystemReference** (Display string: 'Scan 3d Coordinate System Reference'): Scan 3d Coordinate System Reference\n"
		"- **Scan3dCoordinateScale** (Display string: 'Scan 3d Coordinate Scale'): Scan 3d Coordinate Scale\n"
		"- **Scan3dCoordinateOffset** (Display string: 'Scan 3d Coordinate Offset'): Scan 3d Coordinate Offset\n"
		"- **Scan3dInvalidDataFlag** (Display string: 'Scan 3d Invalid Data Flag'): Scan 3d Invalid Data Flag\n"
		"- **Scan3dInvalidDataValue** (Display string: 'Scan 3d Invalid Data Value'): Scan 3d Invalid Data Value\n"
		"- **Scan3dAxisMin** (Display string: 'Scan 3d Axis Min'): Scan 3d Axis Min\n"
		"- **Scan3dAxisMax** (Display string: 'Scan 3d Axis Max'): Scan 3d Axis Max\n"
		"- **Scan3dCoordinateTransformValue** (Display string: 'Scan 3d Coordinate Transform Value'): Scan 3d Coordinate Transform Value\n"
		"- **Scan3dCoordinateReferenceValue** (Display string: 'Scan 3d Coordinate Reference Value'): Scan 3d Coordinate Reference Value\n"
		"- **AdditionalInfo** (Display string: 'Additional Info')\n"
		"- **JPEG** (Display string: 'JPEG')\n"
		"- **mvCustomIdentifier** (Display string: 'mv Custom Identifier')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkEnable_get", _wrap_ChunkDataControl_chunkEnable_get, METH_O, "\n"
		"A boolean property. Enables the inclusion of the selected Chunk data in the payload of the image.\n"
		"Enables the inclusion of the selected Chunk data in the payload of the image.\n"
		""},
	 { "ChunkDataControl_chunkRegionSelector_get", _wrap_ChunkDataControl_chunkRegionSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Region to retrieve data from.\n"
		"Selects which Region to retrieve data from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Region0** (Display string: 'Region 0'): Image comes from the Region 0.\n"
		"- **Region1** (Display string: 'Region 1'): Image comes from the Region 1.\n"
		"- **Region2** (Display string: 'Region 2'): Image comes from the Region 2.\n"
		"- **Scan3dExtraction0** (Display string: 'Scan 3d Extraction 0'): Image comes from the Scan3dExtraction output Region 0.\n"
		"- **Scan3dExtraction1** (Display string: 'Scan 3d Extraction 1'): Image comes from the Scan3dExtraction output Region 1.\n"
		"- **Scan3dExtraction2** (Display string: 'Scan 3d Extraction 2'): Image comes from the Scan3dExtraction output Region 2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkRegionID_get", _wrap_ChunkDataControl_chunkRegionID_get, METH_O, "\n"
		"An enumerated integer property. Returns the Identifier of Region that the image comes from.\n"
		"Returns the Identifier of Region that the image comes from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Region0** (Display string: 'Region 0'): Image comes from the Region 0.\n"
		"- **Region1** (Display string: 'Region 1'): Image comes from the Region 1.\n"
		"- **Region2** (Display string: 'Region 2'): Image comes from the Region 2.\n"
		"- **Scan3dExtraction0** (Display string: 'Scan 3d Extraction 0'): Image comes from the Scan3dExtraction output Region 0.\n"
		"- **Scan3dExtraction1** (Display string: 'Scan 3d Extraction 1'): Image comes from the Scan3dExtraction output Region 1.\n"
		"- **Scan3dExtraction2** (Display string: 'Scan 3d Extraction 2'): Image comes from the Scan3dExtraction output Region 2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkRegionIDValue_get", _wrap_ChunkDataControl_chunkRegionIDValue_get, METH_O, "\n"
		"An integer property. Returns the unique integer Identifier value of the Region that the image comes from.\n"
		"Returns the unique integer Identifier value of the Region that the image comes from.\n"
		""},
	 { "ChunkDataControl_chunkComponentSelector_get", _wrap_ChunkDataControl_chunkComponentSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the Component from which to retrieve data from.\n"
		"Selects the Component from which to retrieve data from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Intensity** (Display string: 'Intensity'): The image data is the intensity component (visible).\n"
		"- **Infrared** (Display string: 'Infrared'): The image data is the infrared component.\n"
		"- **Ultraviolet** (Display string: 'Ultraviolet'): The image data is the ultraviolet component.\n"
		"- **Range** (Display string: 'Range'): The image data is the range component (distance or depth).\n"
		"- **Reflectance** (Display string: 'Reflectance'): The image data is the reflected intensity component (acquired with the Range).\n"
		"- **Disparity** (Display string: 'Disparity'): The image data is the disparity component.\n"
		"- **Confidence** (Display string: 'Confidence'): The image data is the confidence map component.\n"
		"- **Scatter** (Display string: 'Scatter'): The image data is the scatter component.\n"
		"- **Multispectral** (Display string: 'Multispectral'): The image data is the multispectral component.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkComponentID_get", _wrap_ChunkDataControl_chunkComponentID_get, METH_O, "\n"
		"An enumerated integer property. Returns the Identifier of the selected Component.\n"
		"Returns the Identifier of the selected Component. This can be used to identify the image component type of a multi-component payload.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Intensity** (Display string: 'Intensity'): The image data is the intensity component (visible).\n"
		"- **Infrared** (Display string: 'Infrared'): The image data is the infrared component.\n"
		"- **Ultraviolet** (Display string: 'Ultraviolet'): The image data is the ultraviolet component.\n"
		"- **Range** (Display string: 'Range'): The image data is the range component (distance or depth).\n"
		"- **Reflectance** (Display string: 'Reflectance'): The image data is the reflected intensity component (acquired with the Range).\n"
		"- **Disparity** (Display string: 'Disparity'): The image data is the disparity component.\n"
		"- **Confidence** (Display string: 'Confidence'): The image data is the confidence map component.\n"
		"- **Scatter** (Display string: 'Scatter'): The image data is the scatter component.\n"
		"- **Multispectral** (Display string: 'Multispectral'): The image data is the multispectral component.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkComponentIDValue_get", _wrap_ChunkDataControl_chunkComponentIDValue_get, METH_O, "\n"
		"An integer property. Returns a unique Identifier value that corresponds to the selected chunk Component.\n"
		"Returns a unique Identifier value that corresponds to the selected chunk Component.\n"
		""},
	 { "ChunkDataControl_chunkGroupSelector_get", _wrap_ChunkDataControl_chunkGroupSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the component Group from which to retrieve data from.\n"
		"Selects the component Group from which to retrieve data from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Group0** (Display string: 'Group 0'): Selects Components group 0.\n"
		"- **Group1** (Display string: 'Group 1'): Selects Components group 1.\n"
		"- **Group2** (Display string: 'Group 2'): Selects Components group 2.\n"
		"- **Group3** (Display string: 'Group 3'): Selects Components group 3.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkGroupID_get", _wrap_ChunkDataControl_chunkGroupID_get, METH_O, "\n"
		"An enumerated integer property. Returns a unique Identifier corresponding to the selected Group of components.\n"
		"Returns a unique Identifier corresponding to the selected Group of components. This can be used to identify the component Group of a multi-group payload.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Group0** (Display string: 'Group 0'): Selects Components group 0.\n"
		"- **Group1** (Display string: 'Group 1'): Selects Components group 1.\n"
		"- **Group2** (Display string: 'Group 2'): Selects Components group 2.\n"
		"- **Group3** (Display string: 'Group 3'): Selects Components group 3.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkImageComponent_get", _wrap_ChunkDataControl_chunkImageComponent_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated (See ChunkComponentID).\n"
		"Deprecated: \n"
		"This feature is deprecated (See ChunkComponentID). It was representing the component of the payload image.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Intensity** (Display string: 'Intensity'): Intensity\n"
		"- **Infrared** (Display string: 'Infrared'): Infrared\n"
		"- **Ultraviolet** (Display string: 'Ultraviolet'): Ultraviolet\n"
		"- **Range** (Display string: 'Range'): Range\n"
		"- **Reflectance** (Display string: 'Reflectance'): Reflectance\n"
		"- **Disparity** (Display string: 'Disparity'): Disparity\n"
		"- **Scatter** (Display string: 'Scatter'): Scatter\n"
		"- **Confidence** (Display string: 'Confidence'): Confidence\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkGroupIDValue_get", _wrap_ChunkDataControl_chunkGroupIDValue_get, METH_O, "\n"
		"An integer property. Returns a unique Identifier value that corresponds to the Group of Components of the selected chunk Component.\n"
		"Returns a unique Identifier value that corresponds to the Group of Components of the selected chunk Component.\n"
		""},
	 { "ChunkDataControl_chunkPartSelector_get", _wrap_ChunkDataControl_chunkPartSelector_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See ChunkComponentSelector).\n"
		"Deprecated: \n"
		"This feature is deprecated (See ChunkComponentSelector). It was selecting the individual parts of a multi-component/multi-part buffer to access.\n"
		""},
	 { "ChunkDataControl_chunkImage_get", _wrap_ChunkDataControl_chunkImage_get, METH_O, "\n"
		"A string property. Returns the entire image data included in the payload.\n"
		"Returns the entire image data included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkOffsetX_get", _wrap_ChunkDataControl_chunkOffsetX_get, METH_O, "\n"
		"An integer property. Returns the OffsetX of the image included in the payload.\n"
		"Returns the OffsetX of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkOffsetY_get", _wrap_ChunkDataControl_chunkOffsetY_get, METH_O, "\n"
		"An integer property. Returns the OffsetY of the image included in the payload.\n"
		"Returns the OffsetY of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkWidth_get", _wrap_ChunkDataControl_chunkWidth_get, METH_O, "\n"
		"An integer property. Returns the Width of the image included in the payload.\n"
		"Returns the Width of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkHeight_get", _wrap_ChunkDataControl_chunkHeight_get, METH_O, "\n"
		"An integer property. Returns the Height of the image included in the payload.\n"
		"Returns the Height of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkPixelFormat_get", _wrap_ChunkDataControl_chunkPixelFormat_get, METH_O, "\n"
		"An enumerated integer property. Returns the PixelFormat of the image included in the payload.\n"
		"Returns the PixelFormat of the image included in the payload.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Mono1p** (Display string: 'Mono1p'): Mono 1 bit packed.\n"
		"- **Mono2p** (Display string: 'Mono2p'): Mono 2 bit packed.\n"
		"- **Mono4p** (Display string: 'Mono4p'): Mono 4 bit packed.\n"
		"- **Mono8** (Display string: 'Mono8'): Mono 8 bit packed.\n"
		"- **Mono8s** (Display string: 'Mono8s'): Mono 1 bit signed.\n"
		"- **Mono10** (Display string: 'Mono10'): Mono 10 bit.\n"
		"- **Mono10p** (Display string: 'Mono10p'): Mono 10 bit packed.\n"
		"- **Mono12** (Display string: 'Mono12'): Mono 12 bit.\n"
		"- **Mono12p** (Display string: 'Mono12p'): Mono 12 bit packed.\n"
		"- **Mono14** (Display string: 'Mono14'): Mono 14 bit.\n"
		"- **Mono16** (Display string: 'Mono16'): Mono 16 bit.\n"
		"- **R8** (Display string: 'R8'): Red 8 bit.\n"
		"- **G8** (Display string: 'G8'): Green 8 bit.\n"
		"- **B8** (Display string: 'B8'): Blue 8 bit.\n"
		"- **RGB8** (Display string: 'RGB8'): Red, Green, Blue 8 bit\n"
		"- **RGB8_Planar** (Display string: 'RGB8_Planar'): Red, Green, Blue 8 bit planar.\n"
		"- **RGBa8** (Display string: 'RGBa8'): Red, Green, Blue 8 bit aligned on 8 bit\n"
		"- **RGB10** (Display string: 'RGB10'): Red, Green, Blue 10 bit.\n"
		"- **RGB10_Planar** (Display string: 'RGB10_Planar'): Red, Green, Blue 10 bit planar.\n"
		"- **RGB10p32** (Display string: 'RGB10p32'): Red, Green, Blue 10 bit packed in 32 bit pixel.\n"
		"- **RGB12** (Display string: 'RGB12'): Red, Green, Blue 12 bit.\n"
		"- **RGB12_Planar** (Display string: 'RGB12_Planar'): Red, Green, Blue 12 bit planar.\n"
		"- **RGB16** (Display string: 'RGB16'): Red, Green, Blue 16 bit.\n"
		"- **RGB16_Planar** (Display string: 'RGB16_Planar'): Red, Green, Blue 16 bit planar.\n"
		"- **RGB565p** (Display string: 'RGB565p'): Red, Green, Blue 16 bit packet in 5, 6, 5 bits.\n"
		"- **BGR10** (Display string: 'BGR10'): Blue, Green, Red, 10 bit.\n"
		"- **BGR12** (Display string: 'BGR12'): Blue, Green, Red, 12 bit.\n"
		"- **BGR16** (Display string: 'BGR16'): Blue, Green, Red, 16 bit.\n"
		"- **BGR565p** (Display string: 'BGR565p'): Blue, Green, Red, 16 bit packet in 5, 6, 5 bits.\n"
		"- **BGR8** (Display string: 'BGR8'): Blue, Green, Red, 8 bit.\n"
		"- **BGRa8** (Display string: 'BGRa8'): Blue, Green, Red, Alpha 8 bit.\n"
		"- **YUV422_8** (Display string: 'YUV422_8'): YUV 422 8 bit.\n"
		"- **YCbCr411_8** (Display string: 'YCbCr411_8'): YCrCb 411 8 bit.\n"
		"- **YCbCr422_8** (Display string: 'YCbCr422_8'): YCrCb 422 8 bit.\n"
		"- **YCbCr601_422_8** (Display string: 'YCbCr601_422_8'): YCrCb 601 422 8 bit.\n"
		"- **YCbCr709_422_8** (Display string: 'YCbCr709_422_8'): YCrCb 709 422 8 bit.\n"
		"- **YCbCr8** (Display string: 'YCbCr8'): YCbCr 8 bit.\n"
		"- **BayerBG8** (Display string: 'BayerBG8'): Bayer Blue Green 8 bit.\n"
		"- **BayerGB8** (Display string: 'BayerGB8'): Bayer Green Blue 8 bit.\n"
		"- **BayerGR8** (Display string: 'BayerGR8'): Bayer Green Red 8 bit.\n"
		"- **BayerRG8** (Display string: 'BayerRG8'): Bayer Red Green 8 bit.\n"
		"- **BayerBG10** (Display string: 'BayerBG10'): Bayer Blue Green 10 bit.\n"
		"- **BayerGB10** (Display string: 'BayerGB10'): Bayer Green Blue 10 bit.\n"
		"- **BayerGR10** (Display string: 'BayerGR10'): Bayer Green Red 10 bit.\n"
		"- **BayerRG10** (Display string: 'BayerRG10'): Bayer Red Green 10 bit.\n"
		"- **BayerBG12** (Display string: 'BayerBG12'): Bayer Blue Green 12 bit\n"
		"- **BayerGB12** (Display string: 'BayerGB12'): Bayer Green Blue 12 bit\n"
		"- **BayerGR12** (Display string: 'BayerGR12'): Bayer Green Red 12 bit.\n"
		"- **BayerRG12** (Display string: 'BayerRG12'): Bayer Red Green 12 bit.\n"
		"- **BayerBG16** (Display string: 'BayerBG16'): Bayer Blue Green 16 bit.\n"
		"- **BayerGB16** (Display string: 'BayerGB16'): Bayer Green Blue 16 bit.\n"
		"- **BayerGR16** (Display string: 'BayerGR16'): Bayer Green Red 16 bit.\n"
		"- **BayerRG16** (Display string: 'BayerRG16'): Bayer Red Green 16 bit.\n"
		"- **Coord3D_A8** (Display string: 'Coord3D_A8'): 3D coordinate, first component 8 bit.\n"
		"- **Coord3D_B8** (Display string: 'Coord3D_B8'): 3D coordinate, second component 8 bit.\n"
		"- **Coord3D_C8** (Display string: 'Coord3D_C8'): 3D coordinate, third component 8 bit.\n"
		"- **Coord3D_ABC8** (Display string: 'Coord3D_ABC8'): 3D coordinates, 3 components 8 bit.\n"
		"- **Coord3D_ABC8_Planar** (Display string: 'Coord3D_ABC8_Planar'): 3D coordinates, 3 components 8 bit planar.\n"
		"- **Coord3D_A16** (Display string: 'Coord3D_A16'): 3D coordinate, first component 16 bit.\n"
		"- **Coord3D_B16** (Display string: 'Coord3D_B16'): 3D coordinate, second component 16 bit.\n"
		"- **Coord3D_C16** (Display string: 'Coord3D_C16'): 3D coordinate, third component 16 bit.\n"
		"- **Coord3D_ABC16** (Display string: 'Coord3D_ABC16'): 3D coordinates, 3 components 16 bit.\n"
		"- **Coord3D_ABC16_Planar** (Display string: 'Coord3D_ABC16_Planar'): 3D coordinates, 3 components 16 bit planar.\n"
		"- **Coord3D_A32f** (Display string: 'Coord3D_A32f'): 3D coordinate, first component 32 bit float.\n"
		"- **Coord3D_B32f** (Display string: 'Coord3D_B32f'): 3D coordinate, second component 32 bit float.\n"
		"- **Coord3D_C32f** (Display string: 'Coord3D_C32f'): 3D coordinate, third component 32 bit float.\n"
		"- **Coord3D_ABC32f** (Display string: 'Coord3D_ABC32f'): 3D coordinates, 3 components 32 bit float.\n"
		"- **Coord3D_ABC32f_Planar** (Display string: 'Coord3D_ABC32f_Planar'): 3D coordinates, 3 components 32 bit float planar.\n"
		"- **Confidence1** (Display string: 'Confidence1'): Confidence data 1 bit.\n"
		"- **Confidence1p** (Display string: 'Confidence1p'): Confidence data 1 bit packed.\n"
		"- **Confidence8** (Display string: 'Confidence8'): Confidence data 8 bit.\n"
		"- **Confidence16** (Display string: 'Confidence16'): Confidence data 16 bit.\n"
		"- **Confidence32f** (Display string: 'Confidence32f'): Confidence data 32 bit float.\n"
		"- **Data8** (Display string: 'Data8'): Generic non-pixel data 8 bit.\n"
		"- **Data8s** (Display string: 'Data8s'): Generic non-pixel data 8 bit signed.\n"
		"- **Data16** (Display string: 'Data16'): Generic non-pixel data 16 bit.\n"
		"- **Data16s** (Display string: 'Data16s'): Generic non-pixel data 16 bit signed.\n"
		"- **Data32** (Display string: 'Data32'): Generic non-pixel data 32 bit.\n"
		"- **Data32s** (Display string: 'Data32s'): Generic non-pixel data 32 bit signed.\n"
		"- **Data32f** (Display string: 'Data32f'): Generic non-pixel data 32 bit floating point.\n"
		"- **Data64** (Display string: 'Data64'): Generic non-pixel data 64 bit.\n"
		"- **Data64s** (Display string: 'Data64s'): Generic non-pixel data 64 bit signed.\n"
		"- **Data64f** (Display string: 'Data64f'): Generic non-pixel data 64 bit floating point.\n"
		"- **Raw8** (Display string: 'Raw8'): Raw 8 bit.\n"
		"- **Raw16** (Display string: 'Raw16'): Raw 16 bit.\n"
		"- **Mono12Packed** (Display string: 'Mono12Packed'): Mono 12 bit packed (GigE Vision Specific).\n"
		"- **BayerGR10Packed** (Display string: 'BayerGR10Packed'): Bayer GR 10 bit packed (GigE Vision Specific).\n"
		"- **BayerRG10Packed** (Display string: 'BayerRG10Packed'): Bayer RG 10 bit packed (GigE Vision Specific).\n"
		"- **BayerGB10Packed** (Display string: 'BayerGB10Packed'): Bayer GB 10 bit packed (GigE Vision Specific).\n"
		"- **BayerBG10Packed** (Display string: 'BayerBG10Packed'): Bayer BG 10 bit packed (GigE Vision Specific).\n"
		"- **BayerGR12Packed** (Display string: 'BayerGR12Packed'): Bayer GR 12 bit packed (GigE Vision Specific).\n"
		"- **BayerRG12Packed** (Display string: 'BayerRG12Packed'): Bayer RG 12 bit packed (GigE Vision Specific).\n"
		"- **BayerGB12Packed** (Display string: 'BayerGB12Packed'): Bayer GB 12 bit packed (GigE Vision Specific).\n"
		"- **BayerBG12Packed** (Display string: 'BayerBG12Packed'): Bayer BG 12 bit packed (GigE Vision Specific).\n"
		"- **RGB10V1Packed** (Display string: 'RGB10V1Packed'): RGB 10 bit packed (GigE Vision Specific).\n"
		"- **RGB12V1Packed** (Display string: 'RGB12V1Packed'): RGB 12 bit packed (GigE Vision Specific).\n"
		"- **Mono8Signed** (Display string: 'Mono 8 Signed')\n"
		"- **Mono10Packed** (Display string: 'Mono 10 Packed')\n"
		"- **RGB8Packed** (Display string: 'RGB 8 Packed')\n"
		"- **BGR8Packed** (Display string: 'BGR 8 Packed')\n"
		"- **RGBA8Packed** (Display string: 'RGBA 8 Packed')\n"
		"- **BGRA8Packed** (Display string: 'BGRA 8 Packed')\n"
		"- **RGB10Packed** (Display string: 'RGB 10 Packed')\n"
		"- **BGR10Packed** (Display string: 'BGR 10 Packed')\n"
		"- **RGB12Packed** (Display string: 'RGB 12 Packed')\n"
		"- **BGR12Packed** (Display string: 'BGR 12 Packed')\n"
		"- **RGB16Packed** (Display string: 'RGB 16 Packed')\n"
		"- **RGB10V2Packed** (Display string: 'RGB 10 V 2 Packed')\n"
		"- **RGB565Packed** (Display string: 'RGB 565 Packed')\n"
		"- **BGR565Packed** (Display string: 'BGR 565 Packed')\n"
		"- **YUV411Packed** (Display string: 'YUV 411 Packed')\n"
		"- **YUV422Packed** (Display string: 'YUV 422 Packed')\n"
		"- **YUV444Packed** (Display string: 'YUV 444 Packed')\n"
		"- **YUYVPacked** (Display string: 'YUYV Packed')\n"
		"- **RGB8Planar** (Display string: 'RGB 8 Planar')\n"
		"- **RGB10Planar** (Display string: 'RGB 10 Planar')\n"
		"- **RGB12Planar** (Display string: 'RGB 12 Planar')\n"
		"- **RGB16Planar** (Display string: 'RGB 16 Planar')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkPixelDynamicRangeMin_get", _wrap_ChunkDataControl_chunkPixelDynamicRangeMin_get, METH_O, "\n"
		"An integer property. Returns the minimum value of dynamic range of the image included in the payload.\n"
		"Returns the minimum value of dynamic range of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkPixelDynamicRangeMax_get", _wrap_ChunkDataControl_chunkPixelDynamicRangeMax_get, METH_O, "\n"
		"An integer property. Returns the maximum value of dynamic range of the image included in the payload.\n"
		"Returns the maximum value of dynamic range of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkBinningHorizontal_get", _wrap_ChunkDataControl_chunkBinningHorizontal_get, METH_O, "\n"
		"An integer property. Number of horizontal photo-sensitive cells combined together.\n"
		"Number of horizontal photo-sensitive cells combined together.\n"
		""},
	 { "ChunkDataControl_chunkBinningVertical_get", _wrap_ChunkDataControl_chunkBinningVertical_get, METH_O, "\n"
		"An integer property. Number of vertical photo-sensitive cells combined together.\n"
		"Number of vertical photo-sensitive cells combined together.\n"
		""},
	 { "ChunkDataControl_chunkDecimationHorizontal_get", _wrap_ChunkDataControl_chunkDecimationHorizontal_get, METH_O, "\n"
		"An integer property. Horizontal sub-sampling of the image.\n"
		"Horizontal sub-sampling of the image.\n"
		""},
	 { "ChunkDataControl_chunkDecimationVertical_get", _wrap_ChunkDataControl_chunkDecimationVertical_get, METH_O, "\n"
		"An integer property. Vertical sub-sampling of the image.\n"
		"Vertical sub-sampling of the image.\n"
		""},
	 { "ChunkDataControl_chunkReverseX_get", _wrap_ChunkDataControl_chunkReverseX_get, METH_O, "\n"
		"A boolean property. Flip horizontal of the image sent by the device.\n"
		"Flip horizontal of the image sent by the device.\n"
		""},
	 { "ChunkDataControl_chunkReverseY_get", _wrap_ChunkDataControl_chunkReverseY_get, METH_O, "\n"
		"A boolean property. Flip vertically of the image sent by the device.\n"
		"Flip vertically of the image sent by the device.\n"
		""},
	 { "ChunkDataControl_chunkTimestamp_get", _wrap_ChunkDataControl_chunkTimestamp_get, METH_O, "\n"
		"An integer property. Returns the Timestamp of the image included in the payload at the time of the FrameStart internal event.\n"
		"Returns the Timestamp of the image included in the payload at the time of the FrameStart internal event.\n"
		""},
	 { "ChunkDataControl_chunkTimestampLatchValue_get", _wrap_ChunkDataControl_chunkTimestampLatchValue_get, METH_O, "\n"
		"An integer property. Returns the last Timestamp latched with the TimestampLatch command.\n"
		"Returns the last Timestamp latched with the TimestampLatch command.\n"
		""},
	 { "ChunkDataControl_chunkLineStatusAll_get", _wrap_ChunkDataControl_chunkLineStatusAll_get, METH_O, "\n"
		"An integer property. Returns the status of all the I/O lines at the time of the FrameStart internal event.\n"
		"Returns the status of all the I/O lines at the time of the FrameStart internal event.\n"
		""},
	 { "ChunkDataControl_chunkCounterSelector_get", _wrap_ChunkDataControl_chunkCounterSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which counter to retrieve data from.\n"
		"Selects which counter to retrieve data from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Counter0** (Display string: 'Counter 0'): Selects the counter 0.\n"
		"- **Counter1** (Display string: 'Counter 1'): Selects the counter 1.\n"
		"- **Counter2** (Display string: 'Counter 2'): Selects the counter 2.\n"
		"- **Counter3** (Display string: 'Counter 3'): Selects the counter 3.\n"
		"- **Counter4** (Display string: 'Counter 4'): Selects the counter 4.\n"
		"- **Counter5** (Display string: 'Counter 5'): Selects the counter 5.\n"
		"- **Counter6** (Display string: 'Counter 6'): Selects the counter 6.\n"
		"- **Counter7** (Display string: 'Counter 7'): Selects the counter 7.\n"
		"- **Counter8** (Display string: 'Counter 8'): Selects the counter 8.\n"
		"- **Counter9** (Display string: 'Counter 9'): Selects the counter 9.\n"
		"- **Counter10** (Display string: 'Counter 10'): Selects the counter 10.\n"
		"- **Counter11** (Display string: 'Counter 11'): Selects the counter 11.\n"
		"- **Counter12** (Display string: 'Counter 12'): Selects the counter 12.\n"
		"- **Counter13** (Display string: 'Counter 13'): Selects the counter 13.\n"
		"- **Counter14** (Display string: 'Counter 14'): Selects the counter 14.\n"
		"- **Counter15** (Display string: 'Counter 15'): Selects the counter 15.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkCounterValue_get", _wrap_ChunkDataControl_chunkCounterValue_get, METH_O, "\n"
		"An integer property. Returns the value of the selected Chunk counter at the time of the FrameStart event.\n"
		"Returns the value of the selected Chunk counter at the time of the FrameStart event.\n"
		""},
	 { "ChunkDataControl_chunkTimerSelector_get", _wrap_ChunkDataControl_chunkTimerSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Timer to retrieve data from.\n"
		"Selects which Timer to retrieve data from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Timer0** (Display string: 'Timer 0'): Selects the first Timer.\n"
		"- **Timer1** (Display string: 'Timer 1'): Selects the first Timer.\n"
		"- **Timer2** (Display string: 'Timer 2'): Selects the second Timer.\n"
		"- **Timer3** (Display string: 'Timer 3'): Selects the second Timer.\n"
		"- **Timer4** (Display string: 'Timer 4'): Selects the second Timer.\n"
		"- **Timer5** (Display string: 'Timer 5'): Selects the second Timer.\n"
		"- **Timer6** (Display string: 'Timer 6'): Selects the second Timer.\n"
		"- **Timer7** (Display string: 'Timer 7'): Selects the second Timer.\n"
		"- **Timer8** (Display string: 'Timer 8'): Selects the second Timer.\n"
		"- **Timer9** (Display string: 'Timer 9'): Selects the second Timer.\n"
		"- **Timer10** (Display string: 'Timer 10'): Selects the second Timer.\n"
		"- **Timer11** (Display string: 'Timer 11'): Selects the second Timer.\n"
		"- **Timer12** (Display string: 'Timer 12'): Selects the second Timer.\n"
		"- **Timer13** (Display string: 'Timer 13'): Selects the second Timer.\n"
		"- **Timer14** (Display string: 'Timer 14'): Selects the second Timer.\n"
		"- **Timer15** (Display string: 'Timer 15'): Selects the second Timer.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkTimerValue_get", _wrap_ChunkDataControl_chunkTimerValue_get, METH_O, "\n"
		"A floating point property. Returns the value of the selected Timer at the time of the FrameStart internal event.\n"
		"Returns the value of the selected Timer at the time of the FrameStart internal event.\n"
		""},
	 { "ChunkDataControl_chunkScanLineSelector_get", _wrap_ChunkDataControl_chunkScanLineSelector_get, METH_O, "\n"
		"An integer property. Index for vector representation of one chunk value per line in an image.\n"
		"Index for vector representation of one chunk value per line in an image.\n"
		""},
	 { "ChunkDataControl_chunkEncoderSelector_get", _wrap_ChunkDataControl_chunkEncoderSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Encoder to retrieve data from.\n"
		"Selects which Encoder to retrieve data from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Encoder0** (Display string: 'Encoder 0'): Selects the first Encoder.\n"
		"- **Encoder1** (Display string: 'Encoder 1'): Selects the first Encoder.\n"
		"- **Encoder2** (Display string: 'Encoder 2'): Selects the second Encoder.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkEncoderValue_get", _wrap_ChunkDataControl_chunkEncoderValue_get, METH_O, "\n"
		"An integer property. Returns the counter's value of the selected Encoder at the time of the FrameStart in area scan mode or the counter's value at the time of the LineStart selected by ChunkScanLineSelector in Linescan mode.\n"
		"Returns the counter's value of the selected Encoder at the time of the FrameStart in area scan mode or the counter's value at the time of the LineStart selected by ChunkScanLineSelector in Linescan mode.\n"
		""},
	 { "ChunkDataControl_chunkEncoderStatus_get", _wrap_ChunkDataControl_chunkEncoderStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the motion status of the selected encoder.\n"
		"Returns the motion status of the selected encoder.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **EncoderUp** (Display string: 'Encoder Up'): The encoder counter last incremented.\n"
		"- **EncoderDown** (Display string: 'Encoder Down'): The encoder counter last decremented.\n"
		"- **EncoderIdle** (Display string: 'Encoder Idle'): The encoder is not active.\n"
		"- **EncoderStatic** (Display string: 'Encoder Static'): No motion within the EncoderTimeout time.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkExposureTimeSelector_get", _wrap_ChunkDataControl_chunkExposureTimeSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which exposure time is read by the ChunkExposureTime feature.\n"
		"Selects which exposure time is read by the ChunkExposureTime feature.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Blue** (Display string: 'Blue'): Selects the blue ExposureTime.\n"
		"- **Common** (Display string: 'Common'): Selects the common ExposureTime.\n"
		"- **Cyan** (Display string: 'Cyan'): Selects the cyan common ExposureTime..\n"
		"- **Green** (Display string: 'Green'): Selects the green ExposureTime.\n"
		"- **Infrared** (Display string: 'Infrared'): Selects the infrared ExposureTime.\n"
		"- **Magenta** (Display string: 'Magenta'): Selects the magenta ExposureTime..\n"
		"- **Red** (Display string: 'Red'): Selects the red common ExposureTime.\n"
		"- **Stage1** (Display string: 'Stage 1'): Selects the first stage ExposureTime.\n"
		"- **Stage2** (Display string: 'Stage 2'): Selects the second stage ExposureTime.\n"
		"- **Ultraviolet** (Display string: 'Ultraviolet'): Selects the ultraviolet ExposureTime.\n"
		"- **Yellow** (Display string: 'Yellow'): Selects the yellow ExposureTime..\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkExposureTime_get", _wrap_ChunkDataControl_chunkExposureTime_get, METH_O, "\n"
		"A floating point property. Returns the exposure time used to capture the image.\n"
		"Returns the exposure time used to capture the image.\n"
		""},
	 { "ChunkDataControl_chunkGainSelector_get", _wrap_ChunkDataControl_chunkGainSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Gain to return.\n"
		"Selects which Gain to return.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): Gain will be applied to all channels or taps.\n"
		"- **AnalogAll** (Display string: 'Analog All'): Gain will be applied to all analog channels or taps.\n"
		"- **AnalogBlue** (Display string: 'Analog Blue'): Gain will be applied to the blue analog channel.\n"
		"- **AnalogGreen** (Display string: 'Analog Green'): Gain will be applied to the green analog channel.\n"
		"- **AnalogRed** (Display string: 'Analog Red'): Gain will be applied to the red analog channel.\n"
		"- **AnalogTap1** (Display string: 'Analog Tap 1'): Analog gain will be applied to Tap 1.\n"
		"- **AnalogTap2** (Display string: 'Analog Tap 2'): Analog gain will be applied to Tap 2.\n"
		"- **AnalogTap3** (Display string: 'Analog Tap 3'): Analog gain will be applied to Tap 3.\n"
		"- **AnalogTap4** (Display string: 'Analog Tap 4'): Analog gain will be applied to Tap 4.\n"
		"- **AnalogTap5** (Display string: 'Analog Tap 5'): Analog gain will be applied to Tap 5.\n"
		"- **AnalogTap6** (Display string: 'Analog Tap 6'): Analog gain will be applied to Tap 6.\n"
		"- **AnalogTap7** (Display string: 'Analog Tap 7'): Analog gain will be applied to Tap 7.\n"
		"- **AnalogTap8** (Display string: 'Analog Tap 8'): Analog gain will be applied to Tap 8.\n"
		"- **AnalogTap9** (Display string: 'Analog Tap 9'): Analog gain will be applied to Tap 9.\n"
		"- **AnalogTap10** (Display string: 'Analog Tap 10'): Analog gain will be applied to Tap 10.\n"
		"- **AnalogTap11** (Display string: 'Analog Tap 11'): Analog gain will be applied to Tap 11.\n"
		"- **AnalogTap12** (Display string: 'Analog Tap 12'): Analog gain will be applied to Tap 12.\n"
		"- **AnalogTap13** (Display string: 'Analog Tap 13'): Analog gain will be applied to Tap 13.\n"
		"- **AnalogTap14** (Display string: 'Analog Tap 14'): Analog gain will be applied to Tap 14.\n"
		"- **AnalogTap15** (Display string: 'Analog Tap 15'): Analog gain will be applied to Tap 15.\n"
		"- **AnalogU** (Display string: 'Analog U'): Gain will be applied to U analog channel.\n"
		"- **AnalogV** (Display string: 'Analog V'): Gain will be applied to V analog channel.\n"
		"- **AnalogY** (Display string: 'Analog Y'): Gain will be applied to Y analog channel.\n"
		"- **Blue** (Display string: 'Blue'): Gain will be applied to the blue channel.\n"
		"- **DigitalAll** (Display string: 'Digital All'): Gain will be applied to all digital channels or taps.\n"
		"- **DigitalBlue** (Display string: 'Digital Blue'): Gain will be applied to the blue digital channel.\n"
		"- **DigitalGreen** (Display string: 'Digital Green'): Gain will be applied to the green digital channel.\n"
		"- **DigitalRed** (Display string: 'Digital Red'): Gain will be applied to the red digital channel.\n"
		"- **DigitalTap1** (Display string: 'Digital Tap 1'): Digital gain will be applied to Tap 1.\n"
		"- **DigitalTap2** (Display string: 'Digital Tap 2'): Digital gain will be applied to Tap 2.\n"
		"- **DigitalTap3** (Display string: 'Digital Tap 3'): Digital gain will be applied to Tap 3.\n"
		"- **DigitalTap4** (Display string: 'Digital Tap 4'): Digital gain will be applied to Tap 4.\n"
		"- **DigitalTap5** (Display string: 'Digital Tap 5'): Digital gain will be applied to Tap 5.\n"
		"- **DigitalTap6** (Display string: 'Digital Tap 6'): Digital gain will be applied to Tap 6.\n"
		"- **DigitalTap7** (Display string: 'Digital Tap 7'): Digital gain will be applied to Tap 7.\n"
		"- **DigitalTap8** (Display string: 'Digital Tap 8'): Digital gain will be applied to Tap 8.\n"
		"- **DigitalTap9** (Display string: 'Digital Tap 9'): Digital gain will be applied to Tap 9.\n"
		"- **DigitalTap10** (Display string: 'Digital Tap 10'): Digital gain will be applied to Tap 10.\n"
		"- **DigitalTap11** (Display string: 'Digital Tap 11'): Digital gain will be applied to Tap 11.\n"
		"- **DigitalTap12** (Display string: 'Digital Tap 12'): Digital gain will be applied to Tap 12.\n"
		"- **DigitalTap13** (Display string: 'Digital Tap 13'): Digital gain will be applied to Tap 13.\n"
		"- **DigitalTap14** (Display string: 'Digital Tap 14'): Digital gain will be applied to Tap 14.\n"
		"- **DigitalTap15** (Display string: 'Digital Tap 15'): Digital gain will be applied to Tap 15.\n"
		"- **DigitalU** (Display string: 'Digital U'): Gain will be applied to U digital channel.\n"
		"- **DigitalV** (Display string: 'Digital V'): Gain will be applied to V digital channel.\n"
		"- **DigitalY** (Display string: 'Digital Y'): Gain will be applied to Y digital channel.\n"
		"- **Green** (Display string: 'Green'): Gain will be applied to the green channel.\n"
		"- **Red** (Display string: 'Red'): Gain will be applied to the red channel.\n"
		"- **Tap1** (Display string: 'Tap 1'): Gain will be applied to Tap 1.\n"
		"- **Tap2** (Display string: 'Tap 2'): Gain will be applied to Tap 2.\n"
		"- **Tap3** (Display string: 'Tap 3'): Gain will be applied to Tap 3.\n"
		"- **Tap4** (Display string: 'Tap 4'): Gain will be applied to Tap 4.\n"
		"- **Tap5** (Display string: 'Tap 5'): Gain will be applied to Tap 5.\n"
		"- **Tap6** (Display string: 'Tap 6'): Gain will be applied to Tap 6.\n"
		"- **Tap7** (Display string: 'Tap 7'): Gain will be applied to Tap 7.\n"
		"- **Tap8** (Display string: 'Tap 8'): Gain will be applied to Tap 8.\n"
		"- **Tap9** (Display string: 'Tap 9'): Gain will be applied to Tap 9.\n"
		"- **Tap10** (Display string: 'Tap 10'): Gain will be applied to Tap 10.\n"
		"- **Tap11** (Display string: 'Tap 11'): Gain will be applied to Tap 11.\n"
		"- **Tap12** (Display string: 'Tap 12'): Gain will be applied to Tap 12.\n"
		"- **Tap13** (Display string: 'Tap 13'): Gain will be applied to Tap 13.\n"
		"- **Tap14** (Display string: 'Tap 14'): Gain will be applied to Tap 14.\n"
		"- **Tap15** (Display string: 'Tap 15'): Gain will be applied to Tap 15.\n"
		"- **U** (Display string: 'U'): Gain will be applied to U channel.\n"
		"- **V** (Display string: 'V'): Gain will be applied to V channel.\n"
		"- **Y** (Display string: 'Y'): Gain will be applied to Y channel.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkGain_get", _wrap_ChunkDataControl_chunkGain_get, METH_O, "\n"
		"A floating point property. Returns the gain used to capture the image.\n"
		"Returns the gain used to capture the image.\n"
		""},
	 { "ChunkDataControl_chunkBlackLevelSelector_get", _wrap_ChunkDataControl_chunkBlackLevelSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Black Level to return.\n"
		"Selects which Black Level to return. Possible values are:\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): Black Level will be applied to all channels or taps.\n"
		"- **Blue** (Display string: 'Blue'): Black Level will be applied to the blue channel.\n"
		"- **Green** (Display string: 'Green'): Black Level will be applied to the green channel.\n"
		"- **Red** (Display string: 'Red'): Black Level will be applied to the red channel.\n"
		"- **Tap1** (Display string: 'Tap 1'): Black Level will be applied to Tap 1.\n"
		"- **Tap2** (Display string: 'Tap 2'): Black Level will be applied to Tap 2.\n"
		"- **Tap3** (Display string: 'Tap 3'): Black Level will be applied to Tap 3.\n"
		"- **Tap4** (Display string: 'Tap 4'): Black Level will be applied to Tap 4.\n"
		"- **Tap5** (Display string: 'Tap 5'): Black Level will be applied to Tap 5.\n"
		"- **Tap6** (Display string: 'Tap 6'): Black Level will be applied to Tap 6.\n"
		"- **Tap7** (Display string: 'Tap 7'): Black Level will be applied to Tap 7.\n"
		"- **Tap8** (Display string: 'Tap 8'): Black Level will be applied to Tap 8.\n"
		"- **Tap9** (Display string: 'Tap 9'): Black Level will be applied to Tap 9.\n"
		"- **Tap10** (Display string: 'Tap 10'): Black Level will be applied to Tap 10.\n"
		"- **Tap11** (Display string: 'Tap 11'): Black Level will be applied to Tap 11.\n"
		"- **Tap12** (Display string: 'Tap 12'): Black Level will be applied to Tap 12.\n"
		"- **Tap13** (Display string: 'Tap 13'): Black Level will be applied to Tap 13.\n"
		"- **Tap14** (Display string: 'Tap 14'): Black Level will be applied to Tap 14.\n"
		"- **Tap15** (Display string: 'Tap 15'): Black Level will be applied to Tap 15.\n"
		"- **U** (Display string: 'U'): Black Level will be applied to U channel.\n"
		"- **V** (Display string: 'V'): Black Level will be applied to V channel.\n"
		"- **Y** (Display string: 'Y'): Black Level will be applied to Y channel.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkBlackLevel_get", _wrap_ChunkDataControl_chunkBlackLevel_get, METH_O, "\n"
		"A floating point property. Returns the black level used to capture the image included in the payload.\n"
		"Returns the black level used to capture the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkLinePitch_get", _wrap_ChunkDataControl_chunkLinePitch_get, METH_O, "\n"
		"An integer property. Returns the LinePitch of the image included in the payload.\n"
		"Returns the LinePitch of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkFrameID_get", _wrap_ChunkDataControl_chunkFrameID_get, METH_O, "\n"
		"An integer property. Returns the unique Identifier of the frame (image or data container) included in the payload.\n"
		"Returns the unique Identifier of the frame (image or data container) included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkSourceSelector_get", _wrap_ChunkDataControl_chunkSourceSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Source to retrieve data from.\n"
		"Selects which Source to retrieve data from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Source0** (Display string: 'Source 0'): Image comes from the Source 0.\n"
		"- **Source1** (Display string: 'Source 1'): Image comes from the Source 1.\n"
		"- **Source2** (Display string: 'Source 2'): Image comes from the Source 2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkSourceID_get", _wrap_ChunkDataControl_chunkSourceID_get, METH_O, "\n"
		"An enumerated integer property. Returns the Identifier of Source that the image comes from.\n"
		"Returns the Identifier of Source that the image comes from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Source0** (Display string: 'Source 0'): Image comes from the Source 0.\n"
		"- **Source1** (Display string: 'Source 1'): Image comes from the Source 1.\n"
		"- **Source2** (Display string: 'Source 2'): Image comes from the Source 2.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkSourceIDValue_get", _wrap_ChunkDataControl_chunkSourceIDValue_get, METH_O, "\n"
		"An integer property. Returns the unique integer Identifier value of the Source that the image comes from.\n"
		"Returns the unique integer Identifier value of the Source that the image comes from.\n"
		""},
	 { "ChunkDataControl_chunkTransferBlockID_get", _wrap_ChunkDataControl_chunkTransferBlockID_get, METH_O, "\n"
		"An integer property. Returns the unique identifier of the transfer block used to transport the payload.\n"
		"Returns the unique identifier of the transfer block used to transport the payload.\n"
		""},
	 { "ChunkDataControl_chunkTransferStreamID_get", _wrap_ChunkDataControl_chunkTransferStreamID_get, METH_O, "\n"
		"An enumerated integer property. Returns identifier of the stream that generated this block.\n"
		"Returns identifier of the stream that generated this block.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Stream0** (Display string: 'Stream 0'): Data comes from Stream0.\n"
		"- **Stream1** (Display string: 'Stream 1'): Data comes from Stream1.\n"
		"- **Stream2** (Display string: 'Stream 2'): Data comes from Stream2.\n"
		"- **Stream3** (Display string: 'Stream 3'): Data comes from Stream3.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkTransferQueueCurrentBlockCount_get", _wrap_ChunkDataControl_chunkTransferQueueCurrentBlockCount_get, METH_O, "\n"
		"An integer property. Returns the current number of blocks in the transfer queue.\n"
		"Returns the current number of blocks in the transfer queue.\n"
		""},
	 { "ChunkDataControl_chunkStreamChannelID_get", _wrap_ChunkDataControl_chunkStreamChannelID_get, METH_O, "\n"
		"An integer property. Returns identifier of the stream channel used to carry the block.\n"
		"Returns identifier of the stream channel used to carry the block.\n"
		""},
	 { "ChunkDataControl_chunkSequencerSetActive_get", _wrap_ChunkDataControl_chunkSequencerSetActive_get, METH_O, "\n"
		"An integer property. Return the index of the active set of the running sequencer included in the payload.\n"
		"Return the index of the active set of the running sequencer included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkScan3dDistanceUnit_get", _wrap_ChunkDataControl_chunkScan3dDistanceUnit_get, METH_O, "\n"
		"An enumerated integer property. Returns the Distance Unit of the payload image.\n"
		"Returns the Distance Unit of the payload image.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Millimeter** (Display string: 'Millimeter'): Default value. Distance values are in millimeter units.\n"
		"- **Inch** (Display string: 'Inch'): Distance values are in inch units.\n"
		"- **Pixel** (Display string: 'Pixel'): Distance values are given as a multiple of the size of a pixel.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkScan3dOutputMode_get", _wrap_ChunkDataControl_chunkScan3dOutputMode_get, METH_O, "\n"
		"An enumerated integer property. Returns the Calibrated Mode of the payload image.\n"
		"Returns the Calibrated Mode of the payload image.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **UncalibratedC** (Display string: 'Uncalibrated C'): Uncalibrated 2.5D Depth map. The distance data does not represent a physical unit and may be non-linear. The data is a 2.5D range map only.\n"
		"- **CalibratedABC_Grid** (Display string: 'Calibrated ABC Grid'): 3 Coordinates in grid organization. The full 3 coordinate data with the grid array organization from the sensor kept.\n"
		"- **CalibratedABC_PointCloud** (Display string: 'Calibrated ABC Point Cloud'): 3 Coordinates without organization. The full 3 coordinate data without any organization of data points. Typically only valid points transmitted giving varying image size.\n"
		"- **CalibratedAC** (Display string: 'Calibrated AC'): 2 Coordinates with fixed B sampling. The data is sent as a A and C coordinates (X,Z or Theta,Rho). The B (Y) axis uses the scale and offset parameters for the B axis.\n"
		"- **CalibratedAC_Linescan** (Display string: 'Calibrated AC Linescan'): 2 Coordinates with varying sampling. The data is sent as a A and C coordinates (X,Z or Theta,Rho). The B (Y) axis comes from the encoder chunk value.\n"
		"- **CalibratedC** (Display string: 'Calibrated C'): Calibrated 2.5D Depth map. The distance data is expressed in the chosen distance unit. The data is a 2.5D range map. No information on X-Y axes available.\n"
		"- **CalibratedC_Linescan** (Display string: 'Calibrated C Linescan'): Depth Map with varying B sampling. The distance data is expressed in the chosen distance unit. The data is a 2.5D range map. The B (Y) axis comes from the encoder chunk value.\n"
		"- **RectifiedC** (Display string: 'Rectified C'): Rectified 2.5D Depth map. The distance data has been rectified to a uniform sampling pattern in the X and Y direction. The data is a 2.5D range map only. If a complete 3D point cloud is rectified but transmitted as explicit coordinates it should be transmitted as one of the 'CalibratedABC' formats.\n"
		"- **RectifiedC_Linescan** (Display string: 'Rectified C Linescan'): Rectified 2.5D Depth map with varying B sampling. The data is sent as rectified 1D profiles using Coord3D_C pixels. The B (Y) axis comes from the encoder chunk value.\n"
		"- **DisparityC** (Display string: 'Disparity C'): Disparity 2.5D Depth map. The distance is inversely proportional to the pixel (disparity) value.\n"
		"- **DisparityC_Linescan** (Display string: 'Disparity C Linescan'): Disparity 2.5D Depth map with varying B sampling. The distance is inversely proportional to the pixel (disparity) value. The B (Y) axis comes from the encoder chunk value.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkScan3dCoordinateSystem_get", _wrap_ChunkDataControl_chunkScan3dCoordinateSystem_get, METH_O, "\n"
		"An enumerated integer property. Returns the Coordinate System of the image included in the payload.\n"
		"Returns the Coordinate System of the image included in the payload.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Cartesian** (Display string: 'Cartesian'): Default value. 3-axis orthogonal, right-hand X-Y-Z.\n"
		"- **Spherical** (Display string: 'Spherical'): A Theta-Phi-Rho coordinate system.\n"
		"- **Cylindrical** (Display string: 'Cylindrical'): A Theta-Y-Rho coordinate system.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkScan3dCoordinateSystemReference_get", _wrap_ChunkDataControl_chunkScan3dCoordinateSystemReference_get, METH_O, "\n"
		"An enumerated integer property. Returns the Coordinate System Position of the image included in the payload.\n"
		"Returns the Coordinate System Position of the image included in the payload.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Anchor** (Display string: 'Anchor'): Default value. Original fixed reference. The coordinate system fixed relative the camera reference point marker is used.\n"
		"- **Transformed** (Display string: 'Transformed'): Transformed reference system. The transformed coordinate system is used according to the definition in the rotation and translation matrices.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkScan3dCoordinateSelector_get", _wrap_ChunkDataControl_chunkScan3dCoordinateSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Coordinate to retrieve data from.\n"
		"Selects which Coordinate to retrieve data from.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **CoordinateA** (Display string: 'Coordinate A'): The first (X or Theta) coordinate\n"
		"- **CoordinateB** (Display string: 'Coordinate B'): The second (Y or Phi) coordinate\n"
		"- **CoordinateC** (Display string: 'Coordinate C'): The third (Z or Rho) coordinate.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkScan3dCoordinateScale_get", _wrap_ChunkDataControl_chunkScan3dCoordinateScale_get, METH_O, "\n"
		"A floating point property. Returns the Scale for the selected coordinate axis of the image included in the payload.\n"
		"Returns the Scale for the selected coordinate axis of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkScan3dCoordinateOffset_get", _wrap_ChunkDataControl_chunkScan3dCoordinateOffset_get, METH_O, "\n"
		"A floating point property. Returns the Offset for the selected coordinate axis of the image included in the payload.\n"
		"Returns the Offset for the selected coordinate axis of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkScan3dInvalidDataFlag_get", _wrap_ChunkDataControl_chunkScan3dInvalidDataFlag_get, METH_O, "\n"
		"A boolean property. Returns if a specific non-valid data flag is used in the data stream.\n"
		"Returns if a specific non-valid data flag is used in the data stream.\n"
		""},
	 { "ChunkDataControl_chunkScan3dInvalidDataValue_get", _wrap_ChunkDataControl_chunkScan3dInvalidDataValue_get, METH_O, "\n"
		"A floating point property. Returns the Invalid Data Value used for the image included in the payload.\n"
		"Returns the Invalid Data Value used for the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkScan3dAxisMin_get", _wrap_ChunkDataControl_chunkScan3dAxisMin_get, METH_O, "\n"
		"A floating point property. Returns the Minimum Axis value for the selected coordinate axis of the image included in the payload.\n"
		"Returns the Minimum Axis value for the selected coordinate axis of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkScan3dAxisMax_get", _wrap_ChunkDataControl_chunkScan3dAxisMax_get, METH_O, "\n"
		"A floating point property. Returns the Maximum Axis value for the selected coordinate axis of the image included in the payload.\n"
		"Returns the Maximum Axis value for the selected coordinate axis of the image included in the payload.\n"
		""},
	 { "ChunkDataControl_chunkScan3dCoordinateTransformSelector_get", _wrap_ChunkDataControl_chunkScan3dCoordinateTransformSelector_get, METH_O, "\n"
		"An enumerated integer property. Selector for transform values.\n"
		"Selector for transform values.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RotationX** (Display string: 'Rotation X'): Rotation around X axis.\n"
		"- **RotationY** (Display string: 'Rotation Y'): Rotation around Y axis.\n"
		"- **RotationZ** (Display string: 'Rotation Z'): Rotation around Z axis.\n"
		"- **TranslationX** (Display string: 'Translation X'): Translation along X axis.\n"
		"- **TranslationY** (Display string: 'Translation Y'): Translation along Y axis.\n"
		"- **TranslationZ** (Display string: 'Translation Z'): Translation along Z axis.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkScan3dTransformValue_get", _wrap_ChunkDataControl_chunkScan3dTransformValue_get, METH_O, "\n"
		"A floating point property. Returns the transform value.\n"
		"Returns the transform value.\n"
		""},
	 { "ChunkDataControl_chunkScan3dCoordinateReferenceSelector_get", _wrap_ChunkDataControl_chunkScan3dCoordinateReferenceSelector_get, METH_O, "\n"
		"An enumerated integer property. Selector to read a coordinate system reference value defining the transform of a point from one system to the other.\n"
		"Selector to read a coordinate system reference value defining the transform of a point from one system to the other.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **RotationX** (Display string: 'Rotation X'): Rotation around X axis.\n"
		"- **RotationY** (Display string: 'Rotation Y'): Rotation around Y axis.\n"
		"- **RotationZ** (Display string: 'Rotation Z'): Rotation around Z axis.\n"
		"- **TranslationX** (Display string: 'Translation X'): X axis translation.\n"
		"- **TranslationY** (Display string: 'Translation Y'): Y axis translation.\n"
		"- **TranslationZ** (Display string: 'Translation Z'): Z axis translation.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "ChunkDataControl_chunkScan3dCoordinateReferenceValue_get", _wrap_ChunkDataControl_chunkScan3dCoordinateReferenceValue_get, METH_O, "\n"
		"A floating point property. Returns the value of a position or pose coordinate for the anchor or transformed coordinate systems relative to the reference point.\n"
		"Returns the value of a position or pose coordinate for the anchor or transformed coordinate systems relative to the reference point.\n"
		""},
	 { "ChunkDataControl_chunkScan3dFocalLength_get", _wrap_ChunkDataControl_chunkScan3dFocalLength_get, METH_O, "\n"
		"A floating point property. Returns the focal length of the camera in pixel.\n"
		"Returns the focal length of the camera in pixel. The focal length depends on the selected region. The value of this feature takes into account horizontal binning, decimation, or any other function changing the image resolution.\n"
		""},
	 { "ChunkDataControl_chunkScan3dBaseline_get", _wrap_ChunkDataControl_chunkScan3dBaseline_get, METH_O, "\n"
		"A floating point property. Returns the baseline as the physical distance of two cameras in a stereo camera setup.\n"
		"Returns the baseline as the physical distance of two cameras in a stereo camera setup. The value of this feature can be used for 3D reconstruction from disparity images. In this case, the unit of the 3D coordinates corresponds to the unit of the baseline.\n"
		""},
	 { "ChunkDataControl_chunkScan3dPrincipalPointU_get", _wrap_ChunkDataControl_chunkScan3dPrincipalPointU_get, METH_O, "\n"
		"A floating point property. Returns the value of this feature gives the horizontal position of the principal point, relative to the region origin, i.e.\n"
		"Returns the value of this feature gives the horizontal position of the principal point, relative to the region origin, i.e. OffsetX. The value of this feature takes into account horizontal binning, decimation, or any other function changing the image resolution.\n"
		""},
	 { "ChunkDataControl_chunkScan3dPrincipalPointV_get", _wrap_ChunkDataControl_chunkScan3dPrincipalPointV_get, METH_O, "\n"
		"A floating point property. Returns the value of this feature gives the vertical position of the principal point, relative to the region origin, i.e.\n"
		"Returns the value of this feature gives the vertical position of the principal point, relative to the region origin, i.e. OffsetY. The value of this feature takes into account vertical binning, decimation, or any other function changing the image resolution.\n"
		""},
	 { "ChunkDataControl_mvChunkJPEG_get", _wrap_ChunkDataControl_mvChunkJPEG_get, METH_O, "\n"
		"A string property. Provides access to a JPEG image transmitted as part of the chunk data.\n"
		"Provides access to a JPEG image transmitted as part of the chunk data.\n"
		""},
	 { "ChunkDataControl_chunkmvCustomIdentifier_get", _wrap_ChunkDataControl_chunkmvCustomIdentifier_get, METH_O, "\n"
		"An integer property. Contains a custom identifier previously specified by the user.\n"
		"Contains a custom identifier previously specified by the user.\n"
		""},
	 { "ChunkDataControl_chunkComponents_get", _wrap_ChunkDataControl_chunkComponents_get, METH_O, "\n"
		"An integer property. Returns the bitmask of components contained in this block.\n"
		"Returns the bitmask of components contained in this block.\n"
		""},
	 { "ChunkDataControl_chunkPartIndex_get", _wrap_ChunkDataControl_chunkPartIndex_get, METH_O, "\n"
		"An integer property. Returns index of the image part in this block depending on selected component.\n"
		"Returns index of the image part in this block depending on selected component.\n"
		""},
	 { "ChunkDataControl_chunkRcNoise_get", _wrap_ChunkDataControl_chunkRcNoise_get, METH_O, "\n"
		"A floating point property. Returns the noise of the image.\n"
		"Returns the noise of the image.\n"
		""},
	 { "ChunkDataControl_chunkRcOut1Reduction_get", _wrap_ChunkDataControl_chunkRcOut1Reduction_get, METH_O, "\n"
		"A floating point property. Returns the Out1 reduction.\n"
		"Returns the Out1 reduction.\n"
		""},
	 { "ChunkDataControl_chunkRcTest_get", _wrap_ChunkDataControl_chunkRcTest_get, METH_O, "\n"
		"A boolean property. True if test image.\n"
		"True if test image.\n"
		""},
	 { "ChunkDataControl_chunkRcBrightness_get", _wrap_ChunkDataControl_chunkRcBrightness_get, METH_O, "\n"
		"A floating point property. Returns the brightness of the image.\n"
		"Returns the brightness of the image\n"
		""},
	 { "ChunkDataControl_chunkRcAutoExposureAdapting_get", _wrap_ChunkDataControl_chunkRcAutoExposureAdapting_get, METH_O, "\n"
		"A boolean property. True if auto exposure is still adapting.\n"
		"True if auto exposure is still adapting.\n"
		""},
	 { "delete_ChunkDataControl", _wrap_delete_ChunkDataControl, METH_O, NULL},
	 { "ChunkDataControl_swigregister", ChunkDataControl_swigregister, METH_O, NULL},
	 { "ChunkDataControl_swiginit", ChunkDataControl_swiginit, METH_VARARGS, NULL},
	 { "new_TestControl", _wrap_new_TestControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::TestControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "TestControl_testPendingAck_get", _wrap_TestControl_testPendingAck_get, METH_O, "\n"
		"An integer property. Tests the device's pending acknowledge feature.\n"
		"Tests the device's pending acknowledge feature. When this feature is written, the device waits a time period corresponding to the value of TestPendingAck before acknowledging the write.\n"
		""},
	 { "TestControl_testEventGenerate_get", _wrap_TestControl_testEventGenerate_get, METH_O, "\n"
		"A method object. Generates a Test Event.\n"
		"Generates a Test Event.\n"
		""},
	 { "TestControl_testPayloadFormatMode_get", _wrap_TestControl_testPayloadFormatMode_get, METH_O, "\n"
		"An enumerated integer property. This feature allows setting a device in test mode and to output a specific payload format for validation of data streaming.\n"
		"This feature allows setting a device in test mode and to output a specific payload format for validation of data streaming. This feature is intended solely for test purposes. The data can be real acquired data or any test pattern.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The test mode is disabled. This feature has no effect and the device is streaming data normally according to its configuration. This option has to be the default after each boot of the device.\n"
		"- **MultiPart** (Display string: 'Multi Part'): The device streams data using multi-part payload format with at least one part in each payload. This option must be present if and only if the device supports the multi-part payload format.\n"
		"- **GenDC** (Display string: 'GenDC'): The device streams data using GenDC payload format with at least one component in each payload. This option must be present if the device supports the GenDC payload format.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_TestControl", _wrap_delete_TestControl, METH_O, NULL},
	 { "TestControl_swigregister", TestControl_swigregister, METH_O, NULL},
	 { "TestControl_swiginit", TestControl_swiginit, METH_VARARGS, NULL},
	 { "new_TransportLayerControl", _wrap_new_TransportLayerControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::TransportLayerControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "TransportLayerControl_payloadSize_get", _wrap_TransportLayerControl_payloadSize_get, METH_O, "\n"
		"An integer property. Provides the number of bytes transferred for each data buffer or chunk on the stream channel.\n"
		"Provides the number of bytes transferred for each data buffer or chunk on the stream channel. This includes any end-of-line, end-of-frame statistics or other stamp data. This is the total size of data payload for a data block.\n"
		""},
	 { "TransportLayerControl_genDCStreamingMode_get", _wrap_TransportLayerControl_genDCStreamingMode_get, METH_O, "\n"
		"An enumerated integer property. Controls the device's streaming format.\n"
		"Controls the device's streaming format.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The device will only stream data in its native format.\n"
		"- **On** (Display string: 'On'): The device will stream all its data in the generic GenDC format.\n"
		"- **Automatic** (Display string: 'Automatic'): The device will automatically choose in which format it streams its data.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_genDCStreamingStatus_get", _wrap_TransportLayerControl_genDCStreamingStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns whether the current device data streaming format is GenDC.\n"
		"Returns whether the current device data streaming format is GenDC. This value is conditioned by the GenDCStreamingMode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The device will only stream data in its native format.\n"
		"- **On** (Display string: 'On'): The device will stream all its data in the generic GenDC format.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_genDCDescriptor_get", _wrap_TransportLayerControl_genDCDescriptor_get, METH_O, "\n"
		"A string property. Returns a preliminary GenDC Descriptor that can be used as reference for the data Container to be streamed out by the device in its current configuration.\n"
		"Returns a preliminary GenDC Descriptor that can be used as reference for the data Container to be streamed out by the device in its current configuration. This information can be used to set up the receiver in advance to be ready for the data Containers to come.\n"
		""},
	 { "TransportLayerControl_genDCFlowMappingTable_get", _wrap_TransportLayerControl_genDCFlowMappingTable_get, METH_O, "\n"
		"A string property. Returns the GenDC Container data Flow mapping table that will be used to transport the GenDC Container.\n"
		"Returns the GenDC Container data Flow mapping table that will be used to transport the GenDC Container.\n"
		""},
	 { "TransportLayerControl_mvU3VPHYErrorCount_get", _wrap_TransportLayerControl_mvU3VPHYErrorCount_get, METH_O, "\n"
		"An integer property. Counts the number of errors on the PHY interface.\n"
		"Counts the number of errors on the PHY interface.\n"
		""},
	 { "TransportLayerControl_mvU3VLNKErrorCount_get", _wrap_TransportLayerControl_mvU3VLNKErrorCount_get, METH_O, "\n"
		"An integer property. Counts the number of errors on the USB3 link.\n"
		"Counts the number of errors on the USB3 link.\n"
		""},
	 { "TransportLayerControl_mvU3VEndpointSelector_get", _wrap_TransportLayerControl_mvU3VEndpointSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the endpoint for the event counters.\n"
		"Selects the endpoint for the event counters.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvControl** (Display string: 'mv Control'): The control endpoint of the camera.\n"
		"- **mvEvent** (Display string: 'mv Event'): The event endpoint of the camera.\n"
		"- **mvStreaming** (Display string: 'mv Streaming'): The streaming endpoint of the camera.\n"
		"- **mvDebug** (Display string: 'mv Debug'): The debug endpoint of the camera.\n"
		"- **mvAll** (Display string: 'mv All'): Sums up data from all endpoints.\n"
		"- **mvReserved** (Display string: 'mv Reserved'): Reserved.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_mvU3VEndpointResetEventCount_get", _wrap_TransportLayerControl_mvU3VEndpointResetEventCount_get, METH_O, "\n"
		"An integer property. Counts the number of reset events received on all endpoints.\n"
		"Counts the number of reset events received on all endpoints.\n"
		""},
	 { "TransportLayerControl_mvU3VEndpointRetryEventCount_get", _wrap_TransportLayerControl_mvU3VEndpointRetryEventCount_get, METH_O, "\n"
		"An integer property. Counts the number of retry events received on all endpoints.\n"
		"Counts the number of retry events received on all endpoints.\n"
		""},
	 { "TransportLayerControl_mvU3VErrorCounterReset_get", _wrap_TransportLayerControl_mvU3VErrorCounterReset_get, METH_O, "\n"
		"A method object. Resets the 'mvU3VPHYErrorCount' and 'mvU3VLNKErrorCount' registers.\n"
		"Resets the 'mvU3VPHYErrorCount' and 'mvU3VLNKErrorCount' registers.\n"
		""},
	 { "TransportLayerControl_mvU3VSpreadSpectrumClockingSupportDisable_get", _wrap_TransportLayerControl_mvU3VSpreadSpectrumClockingSupportDisable_get, METH_O, "\n"
		"A method object. Disable the spread spectrum clocking support.\n"
		"Disable the spread spectrum clocking support.\n"
		""},
	 { "TransportLayerControl_deviceTapGeometry_get", _wrap_TransportLayerControl_deviceTapGeometry_get, METH_O, "\n"
		"An enumerated integer property. This device tap geometry feature describes the geometrical properties characterizing the taps of a camera as presented at the output of the device.\n"
		"This device tap geometry feature describes the geometrical properties characterizing the taps of a camera as presented at the output of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Geometry_1X_1Y** (Display string: 'Geometry_1X_1Y'): Geometry_1X_1Y\n"
		"- **Geometry_1X2_1Y** (Display string: 'Geometry_1X2_1Y'): Geometry_1X2_1Y\n"
		"- **Geometry_1X2_1Y2** (Display string: 'Geometry_1X2_1Y2'): Geometry_1X2_1Y2\n"
		"- **Geometry_2X_1Y** (Display string: 'Geometry_2X_1Y'): Geometry_2X_1Y\n"
		"- **Geometry_2X_1Y2** (Display string: 'Geometry_2X_1Y2'): Geometry_2X_1Y2\n"
		"- **Geometry_2XE_1Y** (Display string: 'Geometry_2XE_1Y'): Geometry_2XE_1Y\n"
		"- **Geometry_2XE_1Y2** (Display string: 'Geometry_2XE_1Y2'): Geometry_2XE_1Y2\n"
		"- **Geometry_2XM_1Y** (Display string: 'Geometry_2XM_1Y'): Geometry_2XM_1Y\n"
		"- **Geometry_2XM_1Y2** (Display string: 'Geometry_2XM_1Y2'): Geometry_2XM_1Y2\n"
		"- **Geometry_1X_1Y2** (Display string: 'Geometry_1X_1Y2'): Geometry_1X_1Y2\n"
		"- **Geometry_1X_2YE** (Display string: 'Geometry_1X_2YE'): Geometry_1X_2YE\n"
		"- **Geometry_1X3_1Y** (Display string: 'Geometry_1X3_1Y'): Geometry_1X3_1Y\n"
		"- **Geometry_3X_1Y** (Display string: 'Geometry_3X_1Y'): Geometry_3X_1Y\n"
		"- **Geometry_1X** (Display string: 'Geometry_1X'): Geometry_1X\n"
		"- **Geometry_1X2** (Display string: 'Geometry_1X2'): Geometry_1X2\n"
		"- **Geometry_2X** (Display string: 'Geometry_2X'): Geometry_2X\n"
		"- **Geometry_2XE** (Display string: 'Geometry_2XE'): Geometry_2XE\n"
		"- **Geometry_2XM** (Display string: 'Geometry_2XM'): Geometry_2XM\n"
		"- **Geometry_1X3** (Display string: 'Geometry_1X3'): Geometry_1X3\n"
		"- **Geometry_3X** (Display string: 'Geometry_3X'): Geometry_3X\n"
		"- **Geometry_1X4_1Y** (Display string: 'Geometry_1X4_1Y'): Geometry_1X4_1Y\n"
		"- **Geometry_4X_1Y** (Display string: 'Geometry_4X_1Y'): Geometry_4X_1Y\n"
		"- **Geometry_2X2_1Y** (Display string: 'Geometry_2X2_1Y'): Geometry_2X2_1Y\n"
		"- **Geometry_2X2E_1Y** (Display string: 'Geometry_2X2E_1Y'): Geometry_2X2E_1Y\n"
		"- **Geometry_2X2M_1Y** (Display string: 'Geometry_2X2M_1Y'): Geometry_2X2M_1Y\n"
		"- **Geometry_1X2_2YE** (Display string: 'Geometry_1X2_2YE'): Geometry_1X2_2YE\n"
		"- **Geometry_2X_2YE** (Display string: 'Geometry_2X_2YE'): Geometry_2X_2YE\n"
		"- **Geometry_2XE_2YE** (Display string: 'Geometry_2XE_2YE'): Geometry_2XE_2YE\n"
		"- **Geometry_2XM_2YE** (Display string: 'Geometry_2XM_2YE'): Geometry_2XM_2YE\n"
		"- **Geometry_1X4** (Display string: 'Geometry_1X4'): Geometry_1X4\n"
		"- **Geometry_4X** (Display string: 'Geometry_4X'): Geometry_4X\n"
		"- **Geometry_2X2** (Display string: 'Geometry_2X2'): Geometry_2X2\n"
		"- **Geometry_2X2E** (Display string: 'Geometry_2X2E'): Geometry_2X2E\n"
		"- **Geometry_2X2M** (Display string: 'Geometry_2X2M'): Geometry_2X2M\n"
		"- **Geometry_1X8_1Y** (Display string: 'Geometry_1X8_1Y'): Geometry_1X8_1Y\n"
		"- **Geometry_8X_1Y** (Display string: 'Geometry_8X_1Y'): Geometry_8X_1Y\n"
		"- **Geometry_4X2_1Y** (Display string: 'Geometry_4X2_1Y'): Geometry_4X2_1Y\n"
		"- **Geometry_2X2E_2YE** (Display string: 'Geometry_2X2E_2YE'): Geometry_2X2E_2YE\n"
		"- **Geometry_1X8** (Display string: 'Geometry_1X8'): Geometry_1X8\n"
		"- **Geometry_8X** (Display string: 'Geometry_8X'): Geometry_8X\n"
		"- **Geometry_4X2** (Display string: 'Geometry_4X2'): Geometry_4X2\n"
		"- **Geometry_4X2E** (Display string: 'Geometry_4X2E'): Geometry_4X2E\n"
		"- **Geometry_4X2E_1Y** (Display string: 'Geometry_4X2E_1Y'): Geometry_4X2E_1Y\n"
		"- **Geometry_1X10_1Y** (Display string: 'Geometry_1X10_1Y'): Geometry_1X10_1Y\n"
		"- **Geometry_10X_1Y** (Display string: 'Geometry_10X_1Y'): Geometry_10X_1Y\n"
		"- **Geometry_1X10** (Display string: 'Geometry_1X10'): Geometry_1X10\n"
		"- **Geometry_10X** (Display string: 'Geometry_10X'): Geometry_10X\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_ptpEnable_get", _wrap_TransportLayerControl_ptpEnable_get, METH_O, "\n"
		"A boolean property. Enables the Precision Time Protocol (PTP).\n"
		"Enables the Precision Time Protocol (PTP).\n"
		""},
	 { "TransportLayerControl_ptpClockAccuracy_get", _wrap_TransportLayerControl_ptpClockAccuracy_get, METH_O, "\n"
		"An enumerated integer property. Indicates the expected accuracy of the device PTP clock when it is the grandmaster, or in the event it becomes the grandmaster.\n"
		"Indicates the expected accuracy of the device PTP clock when it is the grandmaster, or in the event it becomes the grandmaster.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Within25ns** (Display string: 'Within 25ns'): Within 25ns\n"
		"- **Within100ns** (Display string: 'Within 100ns'): Within 100ns\n"
		"- **Within250ns** (Display string: 'Within 250ns'): Within 250ns\n"
		"- **Within1us** (Display string: 'Within 1us'): Within 1us\n"
		"- **Within2p5us** (Display string: 'Within 2p 5us'): Within 2p 5us\n"
		"- **Within10us** (Display string: 'Within 10us'): Within 10us\n"
		"- **Within25us** (Display string: 'Within 25us'): Within 25us\n"
		"- **Within100us** (Display string: 'Within 100us'): Within 100us\n"
		"- **Within250us** (Display string: 'Within 250us'): Within 250us\n"
		"- **Within1ms** (Display string: 'Within 1ms'): Within 1ms\n"
		"- **Within2p5ms** (Display string: 'Within 2p 5ms'): Within 2p 5ms\n"
		"- **Within10ms** (Display string: 'Within 10ms'): Within 10ms\n"
		"- **Within25ms** (Display string: 'Within 25ms'): Within 25ms\n"
		"- **Within100ms** (Display string: 'Within 100ms'): Within 100ms\n"
		"- **Within250ms** (Display string: 'Within 250ms'): Within 250ms\n"
		"- **Within1s** (Display string: 'Within 1s'): Within 1s\n"
		"- **Within10s** (Display string: 'Within 10s'): Within 10s\n"
		"- **GreaterThan10s** (Display string: 'Greater Than 10s'): Greater Than 10s\n"
		"- **AlternatePTPProfile** (Display string: 'Alternate PTP Profile'): Alternate PTP Profile\n"
		"- **Unknown** (Display string: 'Unknown'): Unknown\n"
		"- **Reserved** (Display string: 'Reserved'): Reserved\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_ptpDataSetLatch_get", _wrap_TransportLayerControl_ptpDataSetLatch_get, METH_O, "\n"
		"A method object. Latches the current values from the device's PTP clock data set.\n"
		"Latches the current values from the device's PTP clock data set.\n"
		""},
	 { "TransportLayerControl_ptpStatus_get", _wrap_TransportLayerControl_ptpStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the latched state of the PTP clock.\n"
		"Returns the latched state of the PTP clock.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Initializing** (Display string: 'Initializing'): Initializing\n"
		"- **Faulty** (Display string: 'Faulty'): Faulty\n"
		"- **Disabled** (Display string: 'Disabled'): Disabled\n"
		"- **Listening** (Display string: 'Listening'): Listening\n"
		"- **PreMaster** (Display string: 'Pre Master'): Pre Master\n"
		"- **Master** (Display string: 'Master'): Master\n"
		"- **Passive** (Display string: 'Passive'): Passive\n"
		"- **Uncalibrated** (Display string: 'Uncalibrated'): Uncalibrated\n"
		"- **Slave** (Display string: 'Slave'): Slave\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_ptpServoStatus_get", _wrap_TransportLayerControl_ptpServoStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the latched state of the clock servo.\n"
		"Returns the latched state of the clock servo. When the servo is in a locked state, the value returned is 'Locked'. When the servo is in a non-locked state, a device-specific value can be returned to give specific information. If no device-specific value is available to describe the current state of the clock servo, the value should be 'Unknown'.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Unknown** (Display string: 'Unknown'): Servo state is unknown.\n"
		"- **Locked** (Display string: 'Locked'): Servo is locked\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_ptpOffsetFromMaster_get", _wrap_TransportLayerControl_ptpOffsetFromMaster_get, METH_O, "\n"
		"An integer property. Returns the latched offset from the PTP master clock in nanoseconds.\n"
		"Returns the latched offset from the PTP master clock in nanoseconds.\n"
		""},
	 { "TransportLayerControl_ptpClockID_get", _wrap_TransportLayerControl_ptpClockID_get, METH_O, "\n"
		"An integer property. Returns the latched clock ID of the PTP device.\n"
		"Returns the latched clock ID of the PTP device.\n"
		""},
	 { "TransportLayerControl_ptpParentClockID_get", _wrap_TransportLayerControl_ptpParentClockID_get, METH_O, "\n"
		"An integer property. Returns the latched parent clock ID of the PTP device.\n"
		"Returns the latched parent clock ID of the PTP device. The parent clock ID is the clock ID of the current master clock.\n"
		""},
	 { "TransportLayerControl_ptpGrandmasterClockID_get", _wrap_TransportLayerControl_ptpGrandmasterClockID_get, METH_O, "\n"
		"An integer property. Returns the latched grandmaster clock ID of the PTP device.\n"
		"Returns the latched grandmaster clock ID of the PTP device. The grandmaster clock ID is the clock ID of the current grandmaster clock.\n"
		""},
	 { "TransportLayerControl_ptpMeanPropagationDelay_get", _wrap_TransportLayerControl_ptpMeanPropagationDelay_get, METH_O, "\n"
		"An integer property. Returns the latched mean propagation delay from the current PTP master clock in nanoseconds.\n"
		"Returns the latched mean propagation delay from the current PTP master clock in nanoseconds. The value is valid only when the PtpStatus is Slave.\n"
		""},
	 { "TransportLayerControl_gevVersionMajor_get", _wrap_TransportLayerControl_gevVersionMajor_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See DeviceTLVersionMajor).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceTLVersionMajor). It was representing the major version of the specification.\n"
		""},
	 { "TransportLayerControl_gevVersionMinor_get", _wrap_TransportLayerControl_gevVersionMinor_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See DeviceTLVersionMinor).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceTLVersionMinor). It was representing the minor version of the specification.\n"
		""},
	 { "TransportLayerControl_gevDeviceModeIsBigEndian_get", _wrap_TransportLayerControl_gevDeviceModeIsBigEndian_get, METH_O, "\n"
		"A boolean property. This feature is deprecated (See DeviceRegistersEndianness).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceRegistersEndianness). It was representing the Endianness of the device registers.\n"
		""},
	 { "TransportLayerControl_gevDeviceClass_get", _wrap_TransportLayerControl_gevDeviceClass_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated (See DeviceType).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceType). It was representing the class of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Transmitter** (Display string: 'Transmitter'): Transmitter\n"
		"- **Receiver** (Display string: 'Receiver'): Receiver\n"
		"- **Transceiver** (Display string: 'Transceiver'): Transceiver\n"
		"- **Peripheral** (Display string: 'Peripheral'): Peripheral\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevDeviceModeCharacterSet_get", _wrap_TransportLayerControl_gevDeviceModeCharacterSet_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated (See DeviceCharacterSet).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceCharacterSet). It was representing the character set used by all the strings of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **UTF8** (Display string: 'UTF 8'): UTF 8\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevPhysicalLinkConfiguration_get", _wrap_TransportLayerControl_gevPhysicalLinkConfiguration_get, METH_O, "\n"
		"An enumerated integer property. Controls the principal physical link configuration to use on next restart/power-up of the device.\n"
		"Controls the principal physical link configuration to use on next restart/power-up of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **SingleLink** (Display string: 'Single Link'): Single Link\n"
		"- **MultiLink** (Display string: 'Multi Link'): Multi Link\n"
		"- **StaticLAG** (Display string: 'Static LAG'): Static LAG\n"
		"- **DynamicLAG** (Display string: 'Dynamic LAG'): Dynamic LAG\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevCurrentPhysicalLinkConfiguration_get", _wrap_TransportLayerControl_gevCurrentPhysicalLinkConfiguration_get, METH_O, "\n"
		"An enumerated integer property. Indicates the current physical link configuration of the device.\n"
		"Indicates the current physical link configuration of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **SingleLink** (Display string: 'Single Link'): Single Link\n"
		"- **MultiLink** (Display string: 'Multi Link'): Multi Link\n"
		"- **StaticLAG** (Display string: 'Static LAG'): Static LAG\n"
		"- **DynamicLAG** (Display string: 'Dynamic LAG'): Dynamic LAG\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevActiveLinkCount_get", _wrap_TransportLayerControl_gevActiveLinkCount_get, METH_O, "\n"
		"An integer property. Indicates the current number of active logical links.\n"
		"Indicates the current number of active logical links.\n"
		""},
	 { "TransportLayerControl_gevSupportedOptionSelector_get", _wrap_TransportLayerControl_gevSupportedOptionSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the GEV option to interrogate for existing support.\n"
		"Selects the GEV option to interrogate for existing support.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Action** (Display string: 'Action'): Action\n"
		"- **CCPApplicationSocket** (Display string: 'CCP Application Socket'): CCP Application Socket\n"
		"- **CommandsConcatenation** (Display string: 'Commands Concatenation'): Commands Concatenation\n"
		"- **DiscoveryAckDelay** (Display string: 'Discovery Ack Delay'): Discovery Ack Delay\n"
		"- **DiscoveryAckDelayWritable** (Display string: 'Discovery Ack Delay Writable'): Discovery Ack Delay Writable\n"
		"- **DynamicLAG** (Display string: 'Dynamic LAG'): Dynamic LAG\n"
		"- **Event** (Display string: 'Event'): Event\n"
		"- **EventData** (Display string: 'Event Data'): Event Data\n"
		"- **ExtendedStatusCodes** (Display string: 'Extended Status Codes'): Extended Status Codes\n"
		"- **ExtendedStatusCodesVersion2_0** (Display string: 'Extended Status Codes Version 2 0'): Extended Status Codes Version 2 0\n"
		"- **HeartbeatDisable** (Display string: 'Heartbeat Disable'): Heartbeat Disable\n"
		"- **IEEE1588** (Display string: 'IEEE 1588'): IEEE 1588\n"
		"- **IPConfigurationDHCP** (Display string: 'IP Configuration DHCP'): IP Configuration DHCP\n"
		"- **IPConfigurationLLA** (Display string: 'IP Configuration LLA'): IP Configuration LLA\n"
		"- **IPConfigurationPersistentIP** (Display string: 'IP Configuration Persistent IP'): IP Configuration Persistent IP\n"
		"- **LinkSpeed** (Display string: 'Link Speed'): Link Speed\n"
		"- **ManifestTable** (Display string: 'Manifest Table'): Manifest Table\n"
		"- **MessageChannelSourceSocket** (Display string: 'Message Channel Source Socket'): Message Channel Source Socket\n"
		"- **MultiLink** (Display string: 'Multi Link'): Multi Link\n"
		"- **PAUSEFrameGeneration** (Display string: 'PAUSE Frame Generation'): PAUSE Frame Generation\n"
		"- **PAUSEFrameReception** (Display string: 'PAUSE Frame Reception'): PAUSE Frame Reception\n"
		"- **PacketResend** (Display string: 'Packet Resend'): Packet Resend\n"
		"- **PendingAck** (Display string: 'Pending Ack'): Pending Ack\n"
		"- **PrimaryApplicationSwitchover** (Display string: 'Primary Application Switchover'): Primary Application Switchover\n"
		"- **Ptp** (Display string: 'Ptp'): Ptp\n"
		"- **ScheduledAction** (Display string: 'Scheduled Action'): Scheduled Action\n"
		"- **SerialNumber** (Display string: 'Serial Number'): Serial Number\n"
		"- **SingleLink** (Display string: 'Single Link'): Single Link\n"
		"- **StandardIDMode** (Display string: 'Standard ID Mode'): Standard ID Mode\n"
		"- **StaticLAG** (Display string: 'Static LAG'): Static LAG\n"
		"- **StreamChannel0AllInTransmission** (Display string: 'Stream Channel 0 All In Transmission'): Stream Channel 0 All In Transmission\n"
		"- **StreamChannel0BigAndLittleEndian** (Display string: 'Stream Channel 0 Big And Little Endian'): Stream Channel 0 Big And Little Endian\n"
		"- **StreamChannel0ExtendedChunkData** (Display string: 'Stream Channel 0 Extended Chunk Data'): Stream Channel 0 Extended Chunk Data\n"
		"- **StreamChannel0IPReassembly** (Display string: 'Stream Channel 0 IP Reassembly'): Stream Channel 0 IP Reassembly\n"
		"- **StreamChannel0MultiZone** (Display string: 'Stream Channel 0 Multi Zone'): Stream Channel 0 Multi Zone\n"
		"- **StreamChannel0PacketResendDestination** (Display string: 'Stream Channel 0 Packet Resend Destination'): Stream Channel 0 Packet Resend Destination\n"
		"- **StreamChannel0UnconditionalStreaming** (Display string: 'Stream Channel 0 Unconditional Streaming'): Stream Channel 0 Unconditional Streaming\n"
		"- **StreamChannel1AllInTransmission** (Display string: 'Stream Channel 1 All In Transmission'): Stream Channel 1 All In Transmission\n"
		"- **StreamChannel1BigAndLittleEndian** (Display string: 'Stream Channel 1 Big And Little Endian'): Stream Channel 1 Big And Little Endian\n"
		"- **StreamChannel1ExtendedChunkData** (Display string: 'Stream Channel 1 Extended Chunk Data'): Stream Channel 1 Extended Chunk Data\n"
		"- **StreamChannel1IPReassembly** (Display string: 'Stream Channel 1 IP Reassembly'): Stream Channel 1 IP Reassembly\n"
		"- **StreamChannel1MultiZone** (Display string: 'Stream Channel 1 Multi Zone'): Stream Channel 1 Multi Zone\n"
		"- **StreamChannel1PacketResendDestination** (Display string: 'Stream Channel 1 Packet Resend Destination'): Stream Channel 1 Packet Resend Destination\n"
		"- **StreamChannel1UnconditionalStreaming** (Display string: 'Stream Channel 1 Unconditional Streaming'): Stream Channel 1 Unconditional Streaming\n"
		"- **StreamChannel2AllInTransmission** (Display string: 'Stream Channel 2 All In Transmission'): Stream Channel 2 All In Transmission\n"
		"- **StreamChannel2BigAndLittleEndian** (Display string: 'Stream Channel 2 Big And Little Endian'): Stream Channel 2 Big And Little Endian\n"
		"- **StreamChannel2ExtendedChunkData** (Display string: 'Stream Channel 2 Extended Chunk Data'): Stream Channel 2 Extended Chunk Data\n"
		"- **StreamChannel2IPReassembly** (Display string: 'Stream Channel 2 IP Reassembly'): Stream Channel 2 IP Reassembly\n"
		"- **StreamChannel2MultiZone** (Display string: 'Stream Channel 2 Multi Zone'): Stream Channel 2 Multi Zone\n"
		"- **StreamChannel2PacketResendDestination** (Display string: 'Stream Channel 2 Packet Resend Destination'): Stream Channel 2 Packet Resend Destination\n"
		"- **StreamChannel2UnconditionalStreaming** (Display string: 'Stream Channel 2 Unconditional Streaming'): Stream Channel 2 Unconditional Streaming\n"
		"- **StreamChannelSourceSocket** (Display string: 'Stream Channel Source Socket'): Stream Channel Source Socket\n"
		"- **TestData** (Display string: 'Test Data'): Test Data\n"
		"- **UnconditionalAction** (Display string: 'Unconditional Action'): Unconditional Action\n"
		"- **UserDefinedName** (Display string: 'User Defined Name'): User Defined Name\n"
		"- **WriteMem** (Display string: 'Write Mem'): Write Mem\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevSupportedOption_get", _wrap_TransportLayerControl_gevSupportedOption_get, METH_O, "\n"
		"A boolean property. Returns if the selected GEV option is supported.\n"
		"Returns if the selected GEV option is supported.\n"
		""},
	 { "TransportLayerControl_gevInterfaceSelector_get", _wrap_TransportLayerControl_gevInterfaceSelector_get, METH_O, "\n"
		"An integer property. Selects which logical link to control.\n"
		"Selects which logical link to control.\n"
		""},
	 { "TransportLayerControl_gevLinkSpeed_get", _wrap_TransportLayerControl_gevLinkSpeed_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See DeviceLinkSpeed).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceLinkSpeed). It was representing the speed of transmission negotiated by the given logical link.\n"
		""},
	 { "TransportLayerControl_gevMACAddress_get", _wrap_TransportLayerControl_gevMACAddress_get, METH_O, "\n"
		"An integer property. MAC address of the logical link.\n"
		"MAC address of the logical link.\n"
		""},
	 { "TransportLayerControl_gevPAUSEFrameReception_get", _wrap_TransportLayerControl_gevPAUSEFrameReception_get, METH_O, "\n"
		"A boolean property. Controls whether incoming PAUSE Frames are handled on the given logical link.\n"
		"Controls whether incoming PAUSE Frames are handled on the given logical link.\n"
		""},
	 { "TransportLayerControl_gevPAUSEFrameTransmission_get", _wrap_TransportLayerControl_gevPAUSEFrameTransmission_get, METH_O, "\n"
		"A boolean property. Controls whether PAUSE Frames can be generated on the given logical link.\n"
		"Controls whether PAUSE Frames can be generated on the given logical link.\n"
		""},
	 { "TransportLayerControl_gevCurrentIPConfigurationLLA_get", _wrap_TransportLayerControl_gevCurrentIPConfigurationLLA_get, METH_O, "\n"
		"A boolean property. Controls whether the Link Local Address IP configuration scheme is activated on the given logical link.\n"
		"Controls whether the Link Local Address IP configuration scheme is activated on the given logical link.\n"
		""},
	 { "TransportLayerControl_gevCurrentIPConfigurationDHCP_get", _wrap_TransportLayerControl_gevCurrentIPConfigurationDHCP_get, METH_O, "\n"
		"A boolean property. Controls whether the DHCP IP configuration scheme is activated on the given logical link.\n"
		"Controls whether the DHCP IP configuration scheme is activated on the given logical link.\n"
		""},
	 { "TransportLayerControl_gevCurrentIPConfigurationPersistentIP_get", _wrap_TransportLayerControl_gevCurrentIPConfigurationPersistentIP_get, METH_O, "\n"
		"A boolean property. Controls whether the PersistentIP configuration scheme is activated on the given logical link.\n"
		"Controls whether the PersistentIP configuration scheme is activated on the given logical link.\n"
		""},
	 { "TransportLayerControl_gevCurrentIPAddress_get", _wrap_TransportLayerControl_gevCurrentIPAddress_get, METH_O, "\n"
		"An integer property. Reports the IP address for the given logical link.\n"
		"Reports the IP address for the given logical link.\n"
		""},
	 { "TransportLayerControl_gevCurrentSubnetMask_get", _wrap_TransportLayerControl_gevCurrentSubnetMask_get, METH_O, "\n"
		"An integer property. Reports the subnet mask of the given logical link.\n"
		"Reports the subnet mask of the given logical link.\n"
		""},
	 { "TransportLayerControl_gevCurrentDefaultGateway_get", _wrap_TransportLayerControl_gevCurrentDefaultGateway_get, METH_O, "\n"
		"An integer property. Reports the default gateway IP address of the given logical link.\n"
		"Reports the default gateway IP address of the given logical link.\n"
		""},
	 { "TransportLayerControl_gevIPConfigurationStatus_get", _wrap_TransportLayerControl_gevIPConfigurationStatus_get, METH_O, "\n"
		"An enumerated integer property. Reports the current IP configuration status.\n"
		"Reports the current IP configuration status.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **None** (Display string: 'None'): None\n"
		"- **PersistentIP** (Display string: 'Persistent IP'): Persistent IP\n"
		"- **DHCP** (Display string: 'DHCP'): DHCP\n"
		"- **LLA** (Display string: 'LLA'): LLA\n"
		"- **ForceIP** (Display string: 'Force IP'): Force IP\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevFirstURL_get", _wrap_TransportLayerControl_gevFirstURL_get, METH_O, "\n"
		"A string property. Indicates the first URL to the GenICam XML device description file.\n"
		"Indicates the first URL to the GenICam XML device description file. The First URL is used as the first choice by the application to retrieve the GenICam XML device description file.\n"
		""},
	 { "TransportLayerControl_gevSecondURL_get", _wrap_TransportLayerControl_gevSecondURL_get, METH_O, "\n"
		"A string property. Indicates the second URL to the GenICam XML device description file.\n"
		"Indicates the second URL to the GenICam XML device description file. This URL is an alternative if the application was unsuccessful to retrieve the device description file using the first URL.\n"
		""},
	 { "TransportLayerControl_gevNumberOfInterfaces_get", _wrap_TransportLayerControl_gevNumberOfInterfaces_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See DeviceLinkSelector).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceLinkSelector). It was representing the number of logical links supported by this device.\n"
		""},
	 { "TransportLayerControl_gevPersistentIPAddress_get", _wrap_TransportLayerControl_gevPersistentIPAddress_get, METH_O, "\n"
		"An integer property. Controls the Persistent IP address for this logical link.\n"
		"Controls the Persistent IP address for this logical link. It is only used when the device boots with the Persistent IP configuration scheme.\n"
		""},
	 { "TransportLayerControl_gevPersistentSubnetMask_get", _wrap_TransportLayerControl_gevPersistentSubnetMask_get, METH_O, "\n"
		"An integer property. Controls the Persistent subnet mask associated with the Persistent IP address on this logical link.\n"
		"Controls the Persistent subnet mask associated with the Persistent IP address on this logical link. It is only used when the device boots with the Persistent IP configuration scheme.\n"
		""},
	 { "TransportLayerControl_gevPersistentDefaultGateway_get", _wrap_TransportLayerControl_gevPersistentDefaultGateway_get, METH_O, "\n"
		"An integer property. Controls the persistent default gateway for this logical link.\n"
		"Controls the persistent default gateway for this logical link. It is only used when the device boots with the Persistent IP configuration scheme.\n"
		""},
	 { "TransportLayerControl_gevMessageChannelCount_get", _wrap_TransportLayerControl_gevMessageChannelCount_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See DeviceEventChannelCount).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceEventChannelCount). It was representing the number of message channels supported by this device.\n"
		""},
	 { "TransportLayerControl_gevStreamChannelCount_get", _wrap_TransportLayerControl_gevStreamChannelCount_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See DeviceStreamChannelCount).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceStreamChannelCount). It was representing the number of stream channels supported by this device.\n"
		""},
	 { "TransportLayerControl_gevHeartbeatTimeout_get", _wrap_TransportLayerControl_gevHeartbeatTimeout_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See DeviceLinkHeartbeatTimeout).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceLinkHeartbeatTimeout). It was controlling the current heartbeat timeout in milliseconds.\n"
		""},
	 { "TransportLayerControl_gevTimestampTickFrequency_get", _wrap_TransportLayerControl_gevTimestampTickFrequency_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See the increment of the TimestampLatchValue feature).\n"
		"Deprecated: \n"
		"This feature is deprecated (See the increment of the TimestampLatchValue feature). It was used to indicate the number of timestamp ticks in 1 second (frequency in Hz). If PTP is used, this feature must return 1,000,000,000 (1 GHz).\n"
		""},
	 { "TransportLayerControl_gevTimestampControlLatch_get", _wrap_TransportLayerControl_gevTimestampControlLatch_get, METH_O, "\n"
		"A method object. This feature is deprecated (See TimestampLatch).\n"
		"Deprecated: \n"
		"This feature is deprecated (See TimestampLatch). It was used to latche the current timestamp counter into GevTimestampValue.\n"
		""},
	 { "TransportLayerControl_gevTimestampControlReset_get", _wrap_TransportLayerControl_gevTimestampControlReset_get, METH_O, "\n"
		"A method object. This feature is deprecated (See TimestampReset).\n"
		"Deprecated: \n"
		"This feature is deprecated (See TimestampReset). It was used to reset the timestamp counter to 0. This feature is not available or as no effect when  PTP is used.\n"
		""},
	 { "TransportLayerControl_gevTimestampValue_get", _wrap_TransportLayerControl_gevTimestampValue_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See TimestampLatchValue).\n"
		"Deprecated: \n"
		"This feature is deprecated (See TimestampLatchValue). It was used to return the latched 64-bit value of the timestamp counter.\n"
		""},
	 { "TransportLayerControl_gevDiscoveryAckDelay_get", _wrap_TransportLayerControl_gevDiscoveryAckDelay_get, METH_O, "\n"
		"An integer property. Indicates the maximum randomized delay the device will wait to acknowledge a discovery command.\n"
		"Indicates the maximum randomized delay the device will wait to acknowledge a discovery command.\n"
		""},
	 { "TransportLayerControl_gevIEEE1588_get", _wrap_TransportLayerControl_gevIEEE1588_get, METH_O, "\n"
		"A boolean property. This feature is deprecated (See PtpEnable).\n"
		"Deprecated: \n"
		"This feature is deprecated (See PtpEnable). It was used to enable the IEEE 1588 Precision Time Protocol to control the timestamp register.\n"
		""},
	 { "TransportLayerControl_gevIEEE1588ClockAccuracy_get", _wrap_TransportLayerControl_gevIEEE1588ClockAccuracy_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated (See PtpClockAccurarcy).\n"
		"Deprecated: \n"
		"This feature is deprecated (See PtpClockAccurarcy). It was used to indicate the expected accuracy of the device clock when it is the grandmaster, or in the event it becomes the grandmaster.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Within25ns** (Display string: 'Within 25ns'): Within 25ns\n"
		"- **Within100ns** (Display string: 'Within 100ns'): Within 100ns\n"
		"- **Within250ns** (Display string: 'Within 250ns'): Within 250ns\n"
		"- **Within1us** (Display string: 'Within 1us'): Within 1us\n"
		"- **Within2p5u** (Display string: 'Within 2p 5u'): Within 2p 5u\n"
		"- **Within10us** (Display string: 'Within 10us'): Within 10us\n"
		"- **Within25us** (Display string: 'Within 25us'): Within 25us\n"
		"- **Within100us** (Display string: 'Within 100us'): Within 100us\n"
		"- **Within250us** (Display string: 'Within 250us'): Within 250us\n"
		"- **Within1ms** (Display string: 'Within 1ms'): Within 1ms\n"
		"- **Within2p5ms** (Display string: 'Within 2p 5ms'): Within 2p 5ms\n"
		"- **Within10ms** (Display string: 'Within 10ms'): Within 10ms\n"
		"- **Within25ms** (Display string: 'Within 25ms'): Within 25ms\n"
		"- **Within100ms** (Display string: 'Within 100ms'): Within 100ms\n"
		"- **Within250ms** (Display string: 'Within 250ms'): Within 250ms\n"
		"- **Within1s** (Display string: 'Within 1s'): Within 1s\n"
		"- **Within10s** (Display string: 'Within 10s'): Within 10s\n"
		"- **GreaterThan10s** (Display string: 'Greater Than 10s'): Greater Than 10s\n"
		"- **AlternatePTPProfile** (Display string: 'Alternate PTP Profile'): Alternate PTP Profile\n"
		"- **Unknown** (Display string: 'Unknown'): Unknown\n"
		"- **Reserved** (Display string: 'Reserved'): Reserved\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevIEEE1588Status_get", _wrap_TransportLayerControl_gevIEEE1588Status_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated (See PtpStatus).\n"
		"Deprecated: \n"
		"This feature is deprecated (See PtpStatus). It was used to Provide the status of the IEEE 1588 clock.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Initializing** (Display string: 'Initializing'): Initializing\n"
		"- **Faulty** (Display string: 'Faulty'): Faulty\n"
		"- **Disabled** (Display string: 'Disabled'): Disabled\n"
		"- **Listening** (Display string: 'Listening'): Listening\n"
		"- **PreMaster** (Display string: 'Pre Master'): Pre Master\n"
		"- **Master** (Display string: 'Master'): Master\n"
		"- **Passive** (Display string: 'Passive'): Passive\n"
		"- **Uncalibrated** (Display string: 'Uncalibrated'): Uncalibrated\n"
		"- **Slave** (Display string: 'Slave'): Slave\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevGVCPExtendedStatusCodesSelector_get", _wrap_TransportLayerControl_gevGVCPExtendedStatusCodesSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the GigE Vision version to control extended status codes for.\n"
		"Selects the GigE Vision version to control extended status codes for.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Version1_1** (Display string: 'Version 1 1'): Version 1 1\n"
		"- **Version2_0** (Display string: 'Version 2 0'): Version 2 0\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevGVCPExtendedStatusCodes_get", _wrap_TransportLayerControl_gevGVCPExtendedStatusCodes_get, METH_O, "\n"
		"A boolean property. Enables the generation of extended status codes.\n"
		"Enables the generation of extended status codes.\n"
		""},
	 { "TransportLayerControl_gevGVCPPendingAck_get", _wrap_TransportLayerControl_gevGVCPPendingAck_get, METH_O, "\n"
		"A boolean property. Enables the generation of PENDING_ACK.\n"
		"Enables the generation of PENDING_ACK.\n"
		""},
	 { "TransportLayerControl_gevGVCPHeartbeatDisable_get", _wrap_TransportLayerControl_gevGVCPHeartbeatDisable_get, METH_O, "\n"
		"A boolean property. This feature is deprecated (See DeviceLinkHeartbeatMode).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceLinkHeartbeatMode). It was used to disable the GVCP heartbeat.\n"
		""},
	 { "TransportLayerControl_gevGVCPPendingTimeout_get", _wrap_TransportLayerControl_gevGVCPPendingTimeout_get, METH_O, "\n"
		"An integer property. This feature is deprecated (See DeviceLinkCommandTimeout).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceLinkCommandTimeout). It was used to indicate the longest GVCP command execution time before a device returns a PENDING_ACK.\n"
		""},
	 { "TransportLayerControl_gevPrimaryApplicationSwitchoverKey_get", _wrap_TransportLayerControl_gevPrimaryApplicationSwitchoverKey_get, METH_O, "\n"
		"An integer property. Controls the key to use to authenticate primary application switchover requests.\n"
		"Controls the key to use to authenticate primary application switchover requests.\n"
		""},
	 { "TransportLayerControl_gevGVSPExtendedIDMode_get", _wrap_TransportLayerControl_gevGVSPExtendedIDMode_get, METH_O, "\n"
		"An enumerated integer property. Enables the extended IDs mode.\n"
		"Enables the extended IDs mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Off\n"
		"- **On** (Display string: 'On'): On\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevCCP_get", _wrap_TransportLayerControl_gevCCP_get, METH_O, "\n"
		"An enumerated integer property. Controls the device access privilege of an application.\n"
		"Controls the device access privilege of an application.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **OpenAccess** (Display string: 'Open Access'): Open Access\n"
		"- **ExclusiveAccess** (Display string: 'Exclusive Access'): Exclusive Access\n"
		"- **ControlAccess** (Display string: 'Control Access'): Control Access\n"
		"- **ControlAccessSwitchoverActive** (Display string: 'Control Access Switchover Active'): Control Access Switchover Active\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevPrimaryApplicationSocket_get", _wrap_TransportLayerControl_gevPrimaryApplicationSocket_get, METH_O, "\n"
		"An integer property. Returns the UDP source port of the primary application.\n"
		"Returns the UDP source port of the primary application.\n"
		""},
	 { "TransportLayerControl_gevPrimaryApplicationIPAddress_get", _wrap_TransportLayerControl_gevPrimaryApplicationIPAddress_get, METH_O, "\n"
		"An integer property. Returns the address of the primary application.\n"
		"Returns the address of the primary application.\n"
		""},
	 { "TransportLayerControl_gevMCPHostPort_get", _wrap_TransportLayerControl_gevMCPHostPort_get, METH_O, "\n"
		"An integer property. Controls the port to which the device must send messages.\n"
		"Controls the port to which the device must send messages. Setting this value to 0 closes the message channel.\n"
		""},
	 { "TransportLayerControl_gevMCDA_get", _wrap_TransportLayerControl_gevMCDA_get, METH_O, "\n"
		"An integer property. Controls the destination IP address for the message channel.\n"
		"Controls the destination IP address for the message channel.\n"
		""},
	 { "TransportLayerControl_gevMCTT_get", _wrap_TransportLayerControl_gevMCTT_get, METH_O, "\n"
		"An integer property. Provides the transmission timeout value in milliseconds.\n"
		"Provides the transmission timeout value in milliseconds.\n"
		""},
	 { "TransportLayerControl_gevMCRC_get", _wrap_TransportLayerControl_gevMCRC_get, METH_O, "\n"
		"An integer property. Controls the number of retransmissions allowed when a message channel message times out.\n"
		"Controls the number of retransmissions allowed when a message channel message times out.\n"
		""},
	 { "TransportLayerControl_gevMCSP_get", _wrap_TransportLayerControl_gevMCSP_get, METH_O, "\n"
		"An integer property. This feature indicates the source port for the message channel.\n"
		"This feature indicates the source port for the message channel.\n"
		""},
	 { "TransportLayerControl_gevStreamChannelSelector_get", _wrap_TransportLayerControl_gevStreamChannelSelector_get, METH_O, "\n"
		"An integer property. Selects the stream channel to control.\n"
		"Selects the stream channel to control.\n"
		""},
	 { "TransportLayerControl_gevSCCFGPacketResendDestination_get", _wrap_TransportLayerControl_gevSCCFGPacketResendDestination_get, METH_O, "\n"
		"A boolean property. Enables the alternate IP destination for stream packets resent due to a packet resend request.\n"
		"Enables the alternate IP destination for stream packets resent due to a packet resend request. When True, the source IP address provided in the packet resend command packet is used. When False, the value set in the GevSCDA[GevStreamChannelSelector] feature is used.\n"
		""},
	 { "TransportLayerControl_gevSCCFGAllInTransmission_get", _wrap_TransportLayerControl_gevSCCFGAllInTransmission_get, METH_O, "\n"
		"A boolean property. Enables the selected GVSP transmitter to use the single packet per data block All-in Transmission mode.\n"
		"Enables the selected GVSP transmitter to use the single packet per data block All-in Transmission mode.\n"
		""},
	 { "TransportLayerControl_gevSCCFGUnconditionalStreaming_get", _wrap_TransportLayerControl_gevSCCFGUnconditionalStreaming_get, METH_O, "\n"
		"A boolean property. Enables the camera to continue to stream, for this stream channel, if its control channel is closed or regardless of the reception of any ICMP messages (such as destination unreachable messages).\n"
		"Enables the camera to continue to stream, for this stream channel, if its control channel is closed or regardless of the reception of any ICMP messages (such as destination unreachable messages).\n"
		""},
	 { "TransportLayerControl_gevSCCFGExtendedChunkData_get", _wrap_TransportLayerControl_gevSCCFGExtendedChunkData_get, METH_O, "\n"
		"A boolean property. Enables cameras to use the extended chunk data payload type for this stream channel.\n"
		"Enables cameras to use the extended chunk data payload type for this stream channel.\n"
		""},
	 { "TransportLayerControl_gevSCPDirection_get", _wrap_TransportLayerControl_gevSCPDirection_get, METH_O, "\n"
		"An enumerated integer property. This feature is deprecated (See DeviceStreamChannelType).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceStreamChannelType). It was used to report the direction of the stream channel.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Transmitter** (Display string: 'Transmitter'): Transmitter\n"
		"- **Receiver** (Display string: 'Receiver'): Receiver\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_gevSCPInterfaceIndex_get", _wrap_TransportLayerControl_gevSCPInterfaceIndex_get, METH_O, "\n"
		"An integer property. Index of the logical link to use.\n"
		"Index of the logical link to use.\n"
		""},
	 { "TransportLayerControl_gevSCPHostPort_get", _wrap_TransportLayerControl_gevSCPHostPort_get, METH_O, "\n"
		"An integer property. Controls the port of the selected channel to which a GVSP transmitter must send data stream or the port from which a GVSP receiver may receive data stream.\n"
		"Controls the port of the selected channel to which a GVSP transmitter must send data stream or the port from which a GVSP receiver may receive data stream. Setting this value to 0 closes the stream channel.\n"
		""},
	 { "TransportLayerControl_gevSCPSFireTestPacket_get", _wrap_TransportLayerControl_gevSCPSFireTestPacket_get, METH_O, "\n"
		"A boolean property. Sends a test packet.\n"
		"Sends a test packet. When this feature is set, the device will fire one test packet.\n"
		""},
	 { "TransportLayerControl_gevSCPSDoNotFragment_get", _wrap_TransportLayerControl_gevSCPSDoNotFragment_get, METH_O, "\n"
		"A boolean property. The state of this feature is copied into the 'do not fragment' bit of IP header of each stream packet.\n"
		"The state of this feature is copied into the 'do not fragment' bit of IP header of each stream packet. It can be used by the application to prevent IP fragmentation of packets on the stream channel.\n"
		""},
	 { "TransportLayerControl_gevSCPSBigEndian_get", _wrap_TransportLayerControl_gevSCPSBigEndian_get, METH_O, "\n"
		"A boolean property. This feature is deprecated (See DeviceStreamChannelEndianness).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceStreamChannelEndianness). It was used to control the endianness of multi-byte pixel data for this stream.\n"
		""},
	 { "TransportLayerControl_gevSCPSPacketSize_get", _wrap_TransportLayerControl_gevSCPSPacketSize_get, METH_O, "\n"
		"An integer property. This GigE Vision specific feature corresponds to DeviceStreamChannelPacketSize and should be kept in sync with it.\n"
		"This GigE Vision specific feature corresponds to DeviceStreamChannelPacketSize and should be kept in sync with it. It specifies the stream packet size, in bytes, to send on the selected channel for a GVSP transmitter or specifies the maximum packet size supported by a GVSP receiver.\n"
		""},
	 { "TransportLayerControl_gevSCPD_get", _wrap_TransportLayerControl_gevSCPD_get, METH_O, "\n"
		"An integer property. Controls the delay (in GEV timestamp counter unit) to insert between each packet for this stream channel.\n"
		"Controls the delay (in GEV timestamp counter unit) to insert between each packet for this stream channel. This can be used as a crude flow-control mechanism if the application or the network infrastructure cannot keep up with the packets coming from the device.\n"
		""},
	 { "TransportLayerControl_gevSCDA_get", _wrap_TransportLayerControl_gevSCDA_get, METH_O, "\n"
		"An integer property. Controls the destination IP address of the selected stream channel to which a GVSP transmitter must send data stream or the destination IP address from which a GVSP receiver may receive data stream.\n"
		"Controls the destination IP address of the selected stream channel to which a GVSP transmitter must send data stream or the destination IP address from which a GVSP receiver may receive data stream.\n"
		""},
	 { "TransportLayerControl_gevSCSP_get", _wrap_TransportLayerControl_gevSCSP_get, METH_O, "\n"
		"An integer property. Indicates the source port of the stream channel.\n"
		"Indicates the source port of the stream channel.\n"
		""},
	 { "TransportLayerControl_gevSCZoneCount_get", _wrap_TransportLayerControl_gevSCZoneCount_get, METH_O, "\n"
		"An integer property. Reports the number of zones per block transmitted on the selected stream channel.\n"
		"Reports the number of zones per block transmitted on the selected stream channel.\n"
		""},
	 { "TransportLayerControl_gevSCZoneDirectionAll_get", _wrap_TransportLayerControl_gevSCZoneDirectionAll_get, METH_O, "\n"
		"An integer property. Reports the transmission direction of each zone transmitted on the selected stream channel.\n"
		"Reports the transmission direction of each zone transmitted on the selected stream channel.\n"
		""},
	 { "TransportLayerControl_gevSCZoneConfigurationLock_get", _wrap_TransportLayerControl_gevSCZoneConfigurationLock_get, METH_O, "\n"
		"A boolean property. Controls whether the selected stream channel multi-zone configuration is locked.\n"
		"Controls whether the selected stream channel multi-zone configuration is locked. When locked, the GVSP transmitter is not allowed to change the number of zones and their direction during block acquisition and transmission.\n"
		""},
	 { "TransportLayerControl_aPAUSEMACCtrlFramesTransmitted_get", _wrap_TransportLayerControl_aPAUSEMACCtrlFramesTransmitted_get, METH_O, "\n"
		"An integer property. Reports the number of transmitted PAUSE frames.\n"
		"Reports the number of transmitted PAUSE frames.\n"
		""},
	 { "TransportLayerControl_aPAUSEMACCtrlFramesReceived_get", _wrap_TransportLayerControl_aPAUSEMACCtrlFramesReceived_get, METH_O, "\n"
		"An integer property. Reports the number of received PAUSE frames.\n"
		"Reports the number of received PAUSE frames.\n"
		""},
	 { "TransportLayerControl_clConfiguration_get", _wrap_TransportLayerControl_clConfiguration_get, METH_O, "\n"
		"An enumerated integer property. This Camera Link specific feature describes the configuration used by the camera.\n"
		"This Camera Link specific feature describes the configuration used by the camera. It helps especially when a camera is capable of operation in a non-standard configuration, and when the features PixelSize, SensorDigitizationTaps, and DeviceTapGeometry do not provide enough information for interpretation of the image data provided by the camera.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Base** (Display string: 'Base'): Standard base configuration described by the Camera Link standard.\n"
		"- **Medium** (Display string: 'Medium'): Standard medium configuration described by the Camera Link standard.\n"
		"- **Full** (Display string: 'Full'): Standard full configuration described by the Camera Link standard.\n"
		"- **DualBase** (Display string: 'Dual Base'): The camera streams the data from multiple taps (that do not fit in the standard base configuration) through two Camera Link base ports. It is responsibility of the application or frame grabber to reconstruct the full image. Only one of the ports (fixed) serves as the 'master' for serial communication and triggering.\n"
		"- **EightyBit** (Display string: 'Eighty Bit'): Standard 80-bit configuration with 10 taps of 8 bits or 8 taps of 10 bits, as described by the Camera Link standard.\n"
		"- **Deca** (Display string: 'Deca'): This enumeration entry is deprecated. It was used for Deca configuration with 10 taps of 8-bit. Use EightyBit instead.\n"
		"- **Deca** (Display string: 'Deca'): This enumeration entry is deprecated. It was used for Deca configuration with 10 taps of 8-bit. Use EightyBit instead.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_clTimeSlotsCount_get", _wrap_TransportLayerControl_clTimeSlotsCount_get, METH_O, "\n"
		"An enumerated integer property. This Camera Link specific feature describes the time multiplexing of the camera link connection to transfer more than the configuration allows, in one single clock.\n"
		"This Camera Link specific feature describes the time multiplexing of the camera link connection to transfer more than the configuration allows, in one single clock.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **One** (Display string: 'One'): One\n"
		"- **Two** (Display string: 'Two'): Two\n"
		"- **Three** (Display string: 'Three'): Three\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpLinkConfigurationStatus_get", _wrap_TransportLayerControl_cxpLinkConfigurationStatus_get, METH_O, "\n"
		"An enumerated integer property. This feature indicates the current and active Link configuration used by the Device.\n"
		"This feature indicates the current and active Link configuration used by the Device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **None** (Display string: 'None'): The Link configuration of the Device is unknown. Either the configuration operation has failed or there is nothing connected.\n"
		"- **Pending** (Display string: 'Pending'): The Device is in the process of configuring the Link. The Link cannot be used yet.\n"
		"- **CXP1_X1** (Display string: 'CXP 1 X 1'): 1 Connection operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X1** (Display string: 'CXP 2 X 1'): 1 Connection operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X1** (Display string: 'CXP 3 X 1'): 1 Connection operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X1** (Display string: 'CXP 5 X 1'): 1 Connection operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X1** (Display string: 'CXP 6 X 1'): 1 Connection operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X1** (Display string: 'CXP 10 X 1'): 1 Connection operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X1** (Display string: 'CXP 12 X 1'): 1 Connection operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X1** (Display string: 'CXP 25 X 1'): 1 Connection operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X2** (Display string: 'CXP 1 X 2'): 2 Connections operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X2** (Display string: 'CXP 2 X 2'): 2 Connections operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X2** (Display string: 'CXP 3 X 2'): 2 Connections operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X2** (Display string: 'CXP 5 X 2'): 2 Connections operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X2** (Display string: 'CXP 6 X 2'): 2 Connections operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X2** (Display string: 'CXP 10 X 2'): 2 Connections operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X2** (Display string: 'CXP 12 X 2'): 2 Connections operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X2** (Display string: 'CXP 25 X 2'): 2 Connections operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X4** (Display string: 'CXP 1 X 4'): 4 Connections operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X4** (Display string: 'CXP 2 X 4'): 4 Connections operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X4** (Display string: 'CXP 3 X 4'): 4 Connections operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X4** (Display string: 'CXP 5 X 4'): 4 Connections operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X4** (Display string: 'CXP 6 X 4'): 4 Connections operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X4** (Display string: 'CXP 10 X 4'): 4 Connections operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X4** (Display string: 'CXP 12 X 4'): 4 Connections operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X4** (Display string: 'CXP 25 X 4'): 4 Connections operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X8** (Display string: 'CXP 1 X 8'): 8 Connections operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X8** (Display string: 'CXP 2 X 8'): 8 Connections operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X8** (Display string: 'CXP 3 X 8'): 8 Connections operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X8** (Display string: 'CXP 5 X 8'): 8 Connections operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X8** (Display string: 'CXP 6 X 8'): 8 Connections operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X8** (Display string: 'CXP 10 X 8'): 8 Connections operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X8** (Display string: 'CXP 12 X 8'): 8 Connections operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X8** (Display string: 'CXP 25 X 8'): 8 Connections operating at CXP-25 speed (25.78125 Gbps).\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpLinkConfigurationPreferred_get", _wrap_TransportLayerControl_cxpLinkConfigurationPreferred_get, METH_O, "\n"
		"An enumerated integer property. Provides the Link configuration that allows the Transmitter Device to operate in its default mode.\n"
		"Provides the Link configuration that allows the Transmitter Device to operate in its default mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **CXP1_X1** (Display string: 'CXP 1 X 1'): 1 Connection operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X1** (Display string: 'CXP 2 X 1'): 1 Connection operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X1** (Display string: 'CXP 3 X 1'): 1 Connection operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X1** (Display string: 'CXP 5 X 1'): 1 Connection operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X1** (Display string: 'CXP 6 X 1'): 1 Connection operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X1** (Display string: 'CXP 10 X 1'): 1 Connection operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X1** (Display string: 'CXP 12 X 1'): 1 Connection operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X1** (Display string: 'CXP 25 X 1'): 1 Connection operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X2** (Display string: 'CXP 1 X 2'): 2 Connections operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X2** (Display string: 'CXP 2 X 2'): 2 Connections operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X2** (Display string: 'CXP 3 X 2'): 2 Connections operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X2** (Display string: 'CXP 5 X 2'): 2 Connections operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X2** (Display string: 'CXP 6 X 2'): 2 Connections operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X2** (Display string: 'CXP 10 X 2'): 2 Connections operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X2** (Display string: 'CXP 12 X 2'): 2 Connections operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X2** (Display string: 'CXP 25 X 2'): 2 Connections operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X4** (Display string: 'CXP 1 X 4'): 4 Connections operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X4** (Display string: 'CXP 2 X 4'): 4 Connections operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X4** (Display string: 'CXP 3 X 4'): 4 Connections operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X4** (Display string: 'CXP 5 X 4'): 4 Connections operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X4** (Display string: 'CXP 6 X 4'): 4 Connections operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X4** (Display string: 'CXP 10 X 4'): 4 Connections operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X4** (Display string: 'CXP 12 X 4'): 4 Connections operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X4** (Display string: 'CXP 25 X 4'): 4 Connections  operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X8** (Display string: 'CXP 1 X 8'): 8 Connections  operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X8** (Display string: 'CXP 2 X 8'): 8 Connections  operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X8** (Display string: 'CXP 3 X 8'): 8 Connections  operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X8** (Display string: 'CXP 5 X 8'): 8 Connections  operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X8** (Display string: 'CXP 6 X 8'): 8 Connections  operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X8** (Display string: 'CXP 10 X 8'): 8 Connections  operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X8** (Display string: 'CXP 12 X 8'): 8 Connections  operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X8** (Display string: 'CXP 25 X 8'): 8 Connections  operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X3** (Display string: 'CXP 1 X 3')\n"
		"- **CXP2_X3** (Display string: 'CXP 2 X 3')\n"
		"- **CXP3_X3** (Display string: 'CXP 3 X 3')\n"
		"- **CXP5_X3** (Display string: 'CXP 5 X 3')\n"
		"- **CXP6_X3** (Display string: 'CXP 6 X 3')\n"
		"- **CXP10_X3** (Display string: 'CXP 10 X 3')\n"
		"- **CXP12_X3** (Display string: 'CXP 12 X 3')\n"
		"- **CXP1_X5** (Display string: 'CXP 1 X 5')\n"
		"- **CXP2_X5** (Display string: 'CXP 2 X 5')\n"
		"- **CXP3_X5** (Display string: 'CXP 3 X 5')\n"
		"- **CXP5_X5** (Display string: 'CXP 5 X 5')\n"
		"- **CXP6_X5** (Display string: 'CXP 6 X 5')\n"
		"- **CXP10_X5** (Display string: 'CXP 10 X 5')\n"
		"- **CXP12_X5** (Display string: 'CXP 12 X 5')\n"
		"- **CXP1_X6** (Display string: 'CXP 1 X 6')\n"
		"- **CXP2_X6** (Display string: 'CXP 2 X 6')\n"
		"- **CXP3_X6** (Display string: 'CXP 3 X 6')\n"
		"- **CXP5_X6** (Display string: 'CXP 5 X 6')\n"
		"- **CXP6_X6** (Display string: 'CXP 6 X 6')\n"
		"- **CXP10_X6** (Display string: 'CXP 10 X 6')\n"
		"- **CXP12_X6** (Display string: 'CXP 12 X 6')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpLinkConfiguration_get", _wrap_TransportLayerControl_cxpLinkConfiguration_get, METH_O, "\n"
		"An enumerated integer property. This feature allows specifying the Link configuration for the communication between the Receiver and Transmitter Device.\n"
		"This feature allows specifying the Link configuration for the communication between the Receiver and Transmitter Device. In most cases this feature does not need to be written because automatic discovery will set configuration correctly to the value returned by CxpLinkConfigurationPreferred. Note that the currently active configuration of the Link can be read using CxpLinkConfigurationStatus.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Auto** (Display string: 'Auto'): Sets Automatic discovery for the Link Configuration.\n"
		"- **CXP1_X1** (Display string: 'CXP 1 X 1'): Force the Link to 1 Connection operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X1** (Display string: 'CXP 2 X 1'): Force the Link to 1 Connection operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X1** (Display string: 'CXP 3 X 1'): Force the Link to 1 Connection operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X1** (Display string: 'CXP 5 X 1'): Force the Link to 1 Connection operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X1** (Display string: 'CXP 6 X 1'): Force the Link to 1 Connection operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X1** (Display string: 'CXP 10 X 1'): Force the Link to 1 Connection operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X1** (Display string: 'CXP 12 X 1'): Force the Link to 1 Connection operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X1** (Display string: 'CXP 25 X 1'): Force the Link to 1 Connection operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X2** (Display string: 'CXP 1 X 2'): Force the Link to 2 Connections operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X2** (Display string: 'CXP 2 X 2'): Force the Link to 2 Connections operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X2** (Display string: 'CXP 3 X 2'): Force the Link to 2 Connections operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X2** (Display string: 'CXP 5 X 2'): Force the Link to 2 Connections operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X2** (Display string: 'CXP 6 X 2'): Force the Link to 2 Connections operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X2** (Display string: 'CXP 10 X 2'): Force the Link to 2 Connections operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X2** (Display string: 'CXP 12 X 2'): Force the Link to 2 Connections operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X2** (Display string: 'CXP 25 X 2'): Force the Link to 2 Connections operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X4** (Display string: 'CXP 1 X 4'): Force the Link to 4 Connections operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X4** (Display string: 'CXP 2 X 4'): Force the Link to 4 Connections operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X4** (Display string: 'CXP 3 X 4'): Force the Link to 4 Connections operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X4** (Display string: 'CXP 5 X 4'): Force the Link to 4 Connections operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X4** (Display string: 'CXP 6 X 4'): Force the Link to 4 Connections operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X4** (Display string: 'CXP 10 X 4'): Force the Link to 4 Connections operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X4** (Display string: 'CXP 12 X 4'): Force the Link to 4 Connections operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X4** (Display string: 'CXP 25 X 4'): Force the Link to 4 Connections operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X8** (Display string: 'CXP 1 X 8'): Force the Link to 8 Connections  operating at CXP-1 speed (1.25 Gbps).\n"
		"- **CXP2_X8** (Display string: 'CXP 2 X 8'): Force the Link to 8 Connections  operating at CXP-2 speed (2.50 Gbps).\n"
		"- **CXP3_X8** (Display string: 'CXP 3 X 8'): Force the Link to 8 Connections  operating at CXP-3 speed (3.125 Gbps).\n"
		"- **CXP5_X8** (Display string: 'CXP 5 X 8'): Force the Link to 8 Connections  operating at CXP-5 speed (5.00 Gbps).\n"
		"- **CXP6_X8** (Display string: 'CXP 6 X 8'): Force the Link to 8 Connections  operating at CXP-6 speed (6.25 Gbps).\n"
		"- **CXP10_X8** (Display string: 'CXP 10 X 8'): Force the Link to 8 Connections  operating at CXP-10 speed (10.00 Gbps).\n"
		"- **CXP12_X8** (Display string: 'CXP 12 X 8'): Force the Link to 8 Connections  operating at CXP-12 speed (12.50 Gbps).\n"
		"- **CXP25_X8** (Display string: 'CXP 25 X 8'): Force the Link to 8 Connections  operating at CXP-25 speed (25.78125 Gbps).\n"
		"- **CXP1_X3** (Display string: 'CXP 1 X 3')\n"
		"- **CXP2_X3** (Display string: 'CXP 2 X 3')\n"
		"- **CXP3_X3** (Display string: 'CXP 3 X 3')\n"
		"- **CXP5_X3** (Display string: 'CXP 5 X 3')\n"
		"- **CXP6_X3** (Display string: 'CXP 6 X 3')\n"
		"- **CXP10_X3** (Display string: 'CXP 10 X 3')\n"
		"- **CXP12_X3** (Display string: 'CXP 12 X 3')\n"
		"- **CXP1_X5** (Display string: 'CXP 1 X 5')\n"
		"- **CXP2_X5** (Display string: 'CXP 2 X 5')\n"
		"- **CXP3_X5** (Display string: 'CXP 3 X 5')\n"
		"- **CXP5_X5** (Display string: 'CXP 5 X 5')\n"
		"- **CXP6_X5** (Display string: 'CXP 6 X 5')\n"
		"- **CXP10_X5** (Display string: 'CXP 10 X 5')\n"
		"- **CXP12_X5** (Display string: 'CXP 12 X 5')\n"
		"- **CXP1_X6** (Display string: 'CXP 1 X 6')\n"
		"- **CXP2_X6** (Display string: 'CXP 2 X 6')\n"
		"- **CXP3_X6** (Display string: 'CXP 3 X 6')\n"
		"- **CXP5_X6** (Display string: 'CXP 5 X 6')\n"
		"- **CXP6_X6** (Display string: 'CXP 6 X 6')\n"
		"- **CXP10_X6** (Display string: 'CXP 10 X 6')\n"
		"- **CXP12_X6** (Display string: 'CXP 12 X 6')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpLinkSharingEnable_get", _wrap_TransportLayerControl_cxpLinkSharingEnable_get, METH_O, "\n"
		"A boolean property. Enable or disable the link sharing functionality of the device.\n"
		"Enable or disable the link sharing functionality of the device.\n"
		""},
	 { "TransportLayerControl_cxpLinkSharingSubDeviceSelector_get", _wrap_TransportLayerControl_cxpLinkSharingSubDeviceSelector_get, METH_O, "\n"
		"An integer property. Index of the sub device used in the Link Sharing.\n"
		"Index of the sub device used in the Link Sharing.\n"
		""},
	 { "TransportLayerControl_cxpLinkSharingSubDeviceType_get", _wrap_TransportLayerControl_cxpLinkSharingSubDeviceType_get, METH_O, "\n"
		"An enumerated integer property. This feature provides the type of sub device.\n"
		"This feature provides the type of sub device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Master** (Display string: 'Master'): The sub device is the master.\n"
		"- **Slave** (Display string: 'Slave'): The sub device is a slave.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpLinkSharingHorizontalStripeCount_get", _wrap_TransportLayerControl_cxpLinkSharingHorizontalStripeCount_get, METH_O, "\n"
		"An integer property. This feature provides the number of horizontal stripes that the device implements.\n"
		"This feature provides the number of horizontal stripes that the device implements.\n"
		""},
	 { "TransportLayerControl_cxpLinkSharingVerticalStripeCount_get", _wrap_TransportLayerControl_cxpLinkSharingVerticalStripeCount_get, METH_O, "\n"
		"An integer property. This feature provides the number of vertical stripes that the device implements.\n"
		"This feature provides the number of vertical stripes that the device implements.\n"
		""},
	 { "TransportLayerControl_cxpLinkSharingHorizontalOverlap_get", _wrap_TransportLayerControl_cxpLinkSharingHorizontalOverlap_get, METH_O, "\n"
		"An integer property. This feature provides the number of pixel overlap in the horizontal stripes that the device implements.\n"
		"This feature provides the number of pixel overlap in the horizontal stripes that the device implements.\n"
		""},
	 { "TransportLayerControl_cxpLinkSharingVerticalOverlap_get", _wrap_TransportLayerControl_cxpLinkSharingVerticalOverlap_get, METH_O, "\n"
		"An integer property. This feature provides the number of pixel overlap in the vertical stripes that the device implements.\n"
		"This feature provides the number of pixel overlap in the vertical stripes that the device implements.\n"
		""},
	 { "TransportLayerControl_cxpLinkSharingDuplicateStripe_get", _wrap_TransportLayerControl_cxpLinkSharingDuplicateStripe_get, METH_O, "\n"
		"An integer property. This feature provides the duplicate count in striped system.\n"
		"This feature provides the duplicate count in striped system. A non-zero value sets the number of duplicate images sent to sub-Devices.\n"
		""},
	 { "TransportLayerControl_cxpConnectionSelector_get", _wrap_TransportLayerControl_cxpConnectionSelector_get, METH_O, "\n"
		"An integer property. Selects the CoaXPress physical connection to control.\n"
		"Selects the CoaXPress physical connection to control.\n"
		""},
	 { "TransportLayerControl_cxpConnectionTestMode_get", _wrap_TransportLayerControl_cxpConnectionTestMode_get, METH_O, "\n"
		"An enumerated integer property. Enables the test mode for an individual physical connection of the Device.\n"
		"Enables the test mode for an individual physical connection of the Device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): Off\n"
		"- **Mode1** (Display string: 'Mode 1'): Mode 1\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpConnectionTestErrorCount_get", _wrap_TransportLayerControl_cxpConnectionTestErrorCount_get, METH_O, "\n"
		"An integer property. Reports the current connection error count for test packets received by the device on the connection selected by CxpConnectionSelector.\n"
		"Reports the current connection error count for test packets received by the device on the connection selected by CxpConnectionSelector.\n"
		""},
	 { "TransportLayerControl_cxpSendReceiveSelector_get", _wrap_TransportLayerControl_cxpSendReceiveSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which one of the send or receive features to control.\n"
		"Selects which one of the send or receive features to control.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Send** (Display string: 'Send'): Send\n"
		"- **Receive** (Display string: 'Receive'): Receive\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpConnectionTestPacketCount_get", _wrap_TransportLayerControl_cxpConnectionTestPacketCount_get, METH_O, "\n"
		"An integer property. Reports the current count for the test packets on the connection selected by CxpConnectionSelector.\n"
		"Reports the current count for the test packets on the connection selected by CxpConnectionSelector.\n"
		""},
	 { "TransportLayerControl_cxpErrorCounterSelector_get", _wrap_TransportLayerControl_cxpErrorCounterSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Cxp Error Counter to read or reset.\n"
		"Selects which Cxp Error Counter to read or reset.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **ConnectionLockLoss** (Display string: 'Connection Lock Loss'): Counts the number of times the lock was lost.\n"
		"- **Encoding** (Display string: 'Encoding'): Counts the number of protocol encoding errors detected.\n"
		"- **StreamDataPacketCrc** (Display string: 'Stream Data Packet Crc'): Counts the number of CRC errors detected in a data packet. This counter is only available on the CoaXpress host.\n"
		"- **ControlPacketCrc** (Display string: 'Control Packet Crc'): Counts the number of CRC errors detected in a control packet.\n"
		"- **EventPacketCrc** (Display string: 'Event Packet Crc'): Counts the number of CRC errors detected in an event packet.\n"
		"- **DuplicatedCharactersCorrected** (Display string: 'Duplicated Characters Corrected'): Counts the number of corrected errors in the duplicated characters in CXP control words.\n"
		"- **DuplicatedCharactersUncorrected** (Display string: 'Duplicated Characters Uncorrected'): Counts the number of uncorrected errors in the duplicated characters in CXP control words.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpErrorCounterReset_get", _wrap_TransportLayerControl_cxpErrorCounterReset_get, METH_O, "\n"
		"A method object. Resets the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.\n"
		"Resets the selected Cxp Error Counter on the connection selected by CxpConnectionSelector. The counter starts counting events immediately after the reset.\n"
		""},
	 { "TransportLayerControl_cxpErrorCounterValue_get", _wrap_TransportLayerControl_cxpErrorCounterValue_get, METH_O, "\n"
		"An integer property. Reads the current value of the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.\n"
		"Reads the current value of the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.\n"
		""},
	 { "TransportLayerControl_cxpErrorCounterStatus_get", _wrap_TransportLayerControl_cxpErrorCounterStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the current status of the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.\n"
		"Returns the current status of the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **CounterActive** (Display string: 'Counter Active'): The counter is actively counting errors.\n"
		"- **CounterOverflow** (Display string: 'Counter Overflow'): The counter exceeded its maximum error count.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpPoCxpAuto_get", _wrap_TransportLayerControl_cxpPoCxpAuto_get, METH_O, "\n"
		"A method object. Activate automatic control of the Power over CoaXPress (PoCXP) for the Link.\n"
		"Activate automatic control of the Power over CoaXPress (PoCXP) for the Link.\n"
		""},
	 { "TransportLayerControl_cxpPoCxpTurnOff_get", _wrap_TransportLayerControl_cxpPoCxpTurnOff_get, METH_O, "\n"
		"A method object. Disable Power over CoaXPress (PoCXP) for the Link.\n"
		"Disable Power over CoaXPress (PoCXP) for the Link.\n"
		""},
	 { "TransportLayerControl_cxpPoCxpTripReset_get", _wrap_TransportLayerControl_cxpPoCxpTripReset_get, METH_O, "\n"
		"A method object. Reset the Power over CoaXPress (PoCXP) Link after an over-current trip on the Device connection(s).\n"
		"Reset the Power over CoaXPress (PoCXP) Link after an over-current trip on the Device connection(s).\n"
		""},
	 { "TransportLayerControl_cxpPoCxpStatus_get", _wrap_TransportLayerControl_cxpPoCxpStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the Power over CoaXPress (PoCXP) status of the Device.\n"
		"Returns the Power over CoaXPress (PoCXP) status of the Device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Auto** (Display string: 'Auto'): Normal automatic PoCXP operation.\n"
		"- **Off** (Display string: 'Off'): PoCXP is forced off.\n"
		"- **Tripped** (Display string: 'Tripped'): The Link has shut down because of an over-current trip.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_cxpFirstLineTriggerWithFrameStart_get", _wrap_TransportLayerControl_cxpFirstLineTriggerWithFrameStart_get, METH_O, "\n"
		"A boolean property. Specifies if a FrameStart trigger also triggers the first LineStart at the same time.\n"
		"Specifies if a FrameStart trigger also triggers the first LineStart at the same time.\n"
		""},
	 { "TransportLayerControl_mvGevSCBWControl_get", _wrap_TransportLayerControl_mvGevSCBWControl_get, METH_O, "\n"
		"An enumerated integer property. Selects the bandwidth control for the selected stream channel.\n"
		"This enumeration selects the bandwidth control for the selected stream channel.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **GevSCPD** (Display string: 'Gev SCPD')\n"
		"- **mvGevSCBW** (Display string: 'mv Gev SCBW')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "TransportLayerControl_mvGevSCBW_get", _wrap_TransportLayerControl_mvGevSCBW_get, METH_O, "\n"
		"An integer property. Sets the stream channels max. bandwidth in KBps\n"
		"This value sets the stream channels max. bandwidth in KBps.\n"
		""},
	 { "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage", _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Calculates the effective number of payload packets (not including leader and trailer) per block of data (e.g. an image) for a GigE Vision data stream when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		" Since: 2.5.11\n"
		" :rtype: int\n"
		" :return: The effective number of payload packets (not including leader and trailer) per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.\n"
		"\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":type payloadSizeValue: int\n"
		":param payloadSizeValue: [in] The current value of the *payloadSize* property.\n"
		":type boExtendedID: boolean\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		" Since: 2.5.7\n"
		" :rtype: int\n"
		" :return: The effective number of payload packets (not including leader and trailer) per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.\n"
		"\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":type boExtendedID: boolean\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		"\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		" Since: 2.5.7\n"
		" :rtype: int\n"
		" :return: The effective number of payload packets (not including leader and trailer) per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.\n"
		"\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		""},
	 { "TransportLayerControl_gevGetEffectiveBytesPerImage", _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Calculates the effective bytes per block of data (e.g. an image) for a GigE Vision data stream when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		" Since: 2.5.11\n"
		" :rtype: int\n"
		" :return: The effective bytes per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.\n"
		"\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":type payloadSizeValue: int\n"
		":param payloadSizeValue: [in] The current value of the *payloadSize* property.\n"
		":type boExtendedID: boolean\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Calculates the effective bytes per block of data (e.g. an image) for a GigE Vision data stream when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		" Since: 2.5.7\n"
		" :rtype: int\n"
		" :return: The effective bytes per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.\n"
		"\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":type boExtendedID: boolean\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Calculates the effective bytes per block of data (e.g. an image) for a GigE Vision data stream when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		" Since: 2.5.7\n"
		" :rtype: int\n"
		" :return: The effective bytes per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.\n"
		"\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		""},
	 { "TransportLayerControl_gevGetResultingBandwidth", _wrap_TransportLayerControl_gevGetResultingBandwidth, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Calculates the overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent precise as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		" Since: 2.5.11\n"
		" :rtype: int\n"
		" :return: The overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.\n"
		"\n"
		":type acquisitionFrameRateValue: float\n"
		":param acquisitionFrameRateValue: [in] The overall current or desired frame rate.\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":type payloadSizeValue: int\n"
		":param payloadSizeValue: [in] The current value of the *payloadSize* property.\n"
		":type boExtendedID: boolean\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Calculates the overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent precise as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		" Since: 2.5.7\n"
		" :rtype: int\n"
		" :return: The overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.\n"
		"\n"
		":type acquisitionFrameRateValue: float\n"
		":param acquisitionFrameRateValue: [in] The overall current or desired frame rate.\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":type boExtendedID: boolean\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Calculates the overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent precise as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		" Since: 2.5.7\n"
		" :rtype: int\n"
		" :return: The overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.\n"
		"\n"
		":type acquisitionFrameRateValue: float\n"
		":param acquisitionFrameRateValue: [in] The overall current or desired frame rate.\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		""},
	 { "TransportLayerControl_gevGetResultingPacketDelay", _wrap_TransportLayerControl_gevGetResultingPacketDelay, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Calculates the inter-packet delay needed to achieve a uniform packet and thus payload distribution for GigE Vision data streams when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		"\n"
		" The result of this function should be written to the property **mvIMPACT::acquire::TransportLayerControl::gevSCPD** if supported by the device.\n"
		" Since: 2.5.11\n"
		" :rtype: int\n"
		" :return: The *GevSCPD* value for the given input parameters. If this value is negative, this indicates that the overall bandwidth resulting\n"
		"     from the given input parameters is higher than stated by *bandwidthAvailable*. In such a case the inter-packet delay must be set to 0 and\n"
		"     it should be noted that the desired frame rate cannot be reached in this configuration.\n"
		"\n"
		":type acquisitionFrameRateValue: float\n"
		":param acquisitionFrameRateValue: [in] The overall current or desired frame rate.\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":type payloadSizeValue: int\n"
		":param payloadSizeValue: [in] The current value of the *payloadSize* property.\n"
		":type gevTimestampTickFrequencyValue: int\n"
		":param gevTimestampTickFrequencyValue: [in] The timestamp tick frequency of the GEV remote device.\n"
		":type bandwidthAvailable: int\n"
		":param bandwidthAvailable: [in] The overall bandwidth in bytes that is available on the given link.\n"
		":type boExtendedID: boolean\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Calculates the inter-packet delay needed to achieve a uniform packet and thus payload distribution for GigE Vision data streams when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		"\n"
		" The result of this function should be written to the property **mvIMPACT::acquire::TransportLayerControl::gevSCPD** if supported by the device.\n"
		" Since: 2.5.7\n"
		" :rtype: int\n"
		" :return: The *GevSCPD* value for the given input parameters. If this value is negative, this indicates that the overall bandwidth resulting\n"
		"     from the given input parameters is higher than stated by *bandwidthAvailable*. In such a case the inter-packet delay must be set to 0 and\n"
		"     it should be noted that the desired frame rate cannot be reached in this configuration.\n"
		"\n"
		":type acquisitionFrameRateValue: float\n"
		":param acquisitionFrameRateValue: [in] The overall current or desired frame rate.\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":type gevTimestampTickFrequencyValue: int\n"
		":param gevTimestampTickFrequencyValue: [in] The timestamp tick frequency of the GEV remote device.\n"
		":type bandwidthAvailable: int\n"
		":param bandwidthAvailable: [in] The overall bandwidth in bytes that is available on the given link.\n"
		":type boExtendedID: boolean\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Calculates the inter-packet delay needed to achieve a uniform packet and thus payload distribution for GigE Vision data streams when transferring the payload type *image*.\n"
		" This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when\n"
		" transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However\n"
		" these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.\n"
		"\n"
		" The result of this function should be written to the property **mvIMPACT::acquire::TransportLayerControl::gevSCPD** if supported by the device.\n"
		" Since: 2.5.7\n"
		" :rtype: int\n"
		" :return: The *GevSCPD* value for the given input parameters. If this value is negative, this indicates that the overall bandwidth resulting\n"
		"     from the given input parameters is higher than stated by *bandwidthAvailable*. In such a case the inter-packet delay must be set to 0 and\n"
		"     it should be noted that the desired frame rate cannot be reached in this configuration.\n"
		"\n"
		":type acquisitionFrameRateValue: float\n"
		":param acquisitionFrameRateValue: [in] The overall current or desired frame rate.\n"
		":type gevSCPSPacketSizeValue: int\n"
		":param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.\n"
		":type gevTimestampTickFrequencyValue: int\n"
		":param gevTimestampTickFrequencyValue: [in] The timestamp tick frequency of the GEV remote device.\n"
		":type bandwidthAvailable: int\n"
		":param bandwidthAvailable: [in] The overall bandwidth in bytes that is available on the given link.\n"
		":param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.\n"
		""},
	 { "delete_TransportLayerControl", _wrap_delete_TransportLayerControl, METH_O, NULL},
	 { "TransportLayerControl_swigregister", TransportLayerControl_swigregister, METH_O, NULL},
	 { "TransportLayerControl_swiginit", TransportLayerControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvSerialInterfaceControl", _wrap_new_mvSerialInterfaceControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvSerialInterfaceControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceEnable_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceEnable_get, METH_O, "\n"
		"A boolean property. Controls whether the serial interface is enabled or not.\n"
		"Controls whether the serial interface is enabled or not.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceMode_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceMode_get, METH_O, "\n"
		"An enumerated integer property. States the interface mode of the serial interface\n"
		"States the interface mode of the serial interface\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Plain** (Display string: 'Plain')\n"
		"- **InveniosLiquidLens** (Display string: 'Invenios Liquid Lens')\n"
		"- **OptoEngineeringStepper** (Display string: 'Opto Engineering Stepper')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceBaudRate_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceBaudRate_get, METH_O, "\n"
		"An enumerated integer property. Serial interface clock frequency.\n"
		"Serial interface clock frequency.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Hz_115200** (Display string: '115200 Hz')\n"
		"- **Hz_57600** (Display string: '57600 Hz')\n"
		"- **Hz_38400** (Display string: '38400 Hz')\n"
		"- **Hz_19200** (Display string: '19200 Hz')\n"
		"- **Hz_9600** (Display string: '9600 Hz')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceDataBits_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceDataBits_get, METH_O, "\n"
		"An enumerated integer property. Number of data bits.\n"
		"Number of data bits.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Seven** (Display string: 'Seven')\n"
		"- **Eight** (Display string: 'Eight')\n"
		"- **Nine** (Display string: 'Nine')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceStopBits_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceStopBits_get, METH_O, "\n"
		"An enumerated integer property. Number of stop bits.\n"
		"Number of stop bits.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **One** (Display string: 'One')\n"
		"- **Two** (Display string: 'Two')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceParity_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceParity_get, METH_O, "\n"
		"An enumerated integer property. Serial interface parity.\n"
		"Serial interface parity.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **None** (Display string: 'None')\n"
		"- **Odd** (Display string: 'Odd')\n"
		"- **Even** (Display string: 'Even')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceASCIIBuffer_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceASCIIBuffer_get, METH_O, "\n"
		"A string property. Buffer for exchanging ASCII data over the serial interface. This buffer uses the same memory as 'mvSerialInterfaceBinaryBuffer'.\n"
		"Buffer for exchanging ASCII data over the serial interface. This buffer uses the same memory as 'mvSerialInterfaceBinaryBuffer'.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceBinaryBuffer_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceBinaryBuffer_get, METH_O, "\n"
		"A string property. Buffer for exchanging binary data over the serial interface. This buffer uses the same memory as 'mvSerialInterfaceASCIIBuffer'.\n"
		"Buffer for exchanging binary data over the serial interface. This buffer uses the same memory as 'mvSerialInterfaceASCIIBuffer'.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceBytesToWrite_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceBytesToWrite_get, METH_O, "\n"
		"An integer property. Length of data to write.\n"
		"Length of data to write.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceBytesAvailableForRead_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceBytesAvailableForRead_get, METH_O, "\n"
		"An integer property. Number of serial data bytes available for read.\n"
		"Number of serial data bytes available for read.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceReceiveStatus_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceReceiveStatus_get, METH_O, "\n"
		"An integer property. Result of the serial receive error detection mechanism.\n"
		"Result of the serial receive error detection mechanism.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceBytesToRead_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceBytesToRead_get, METH_O, "\n"
		"An integer property. Number of serial bytes to read.\n"
		"Number of serial bytes to read.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceRead_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceRead_get, METH_O, "\n"
		"A method object. Command to read data from serial interface.\n"
		"Command to read data from serial interface.\n"
		""},
	 { "mvSerialInterfaceControl_mvSerialInterfaceWrite_get", _wrap_mvSerialInterfaceControl_mvSerialInterfaceWrite_get, METH_O, "\n"
		"A method object. Command to write data to serial interface\n"
		"Command to write data to serial interface\n"
		""},
	 { "mvSerialInterfaceControl_mvLiquidLensFirmwareVersion_get", _wrap_mvSerialInterfaceControl_mvLiquidLensFirmwareVersion_get, METH_O, "\n"
		"An integer property. Returns the firmware version of the Liquid Lens.\n"
		"Returns the firmware version of the Liquid Lens.\n"
		""},
	 { "mvSerialInterfaceControl_mvLiquidLensStatus_get", _wrap_mvSerialInterfaceControl_mvLiquidLensStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the current status of the Liquid Lens.\n"
		"Returns the current status of the Liquid Lens.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NoError** (Display string: 'No Error'): No Errors.\n"
		"- **VhOverload** (Display string: 'Vh Overload'): Vh below 70V because Liquid Lens is taking too much current.\n"
		"- **ThermalOverload** (Display string: 'Thermal Overload'): Driver shutdown because Liquid Lens is too hot.\n"
		"- **VhAndThermalOverload** (Display string: 'Vh And Thermal Overload'): Vh does not reach 70V and driver shutdown because Liquid Lens is too hot.\n"
		"- **StatusReadErrorNoAnswer** (Display string: 'Status Read Error No Answer'): No response from Liquid Lens.\n"
		"- **StatusReadErrorCRC** (Display string: 'Status Read Error CRC'): CRC error in response from Liquid Lens.\n"
		"- **StatusReadErrorNakAnswer** (Display string: 'Status Read Error Nak Answer'): NAK response from Liquid Lens.\n"
		"- **StatusReadErrorInvalidAnswer** (Display string: 'Status Read Error Invalid Answer'): Invalid Size or Command in response from Liquid Lens.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvSerialInterfaceControl_mvLiquidLensErrorCount_get", _wrap_mvSerialInterfaceControl_mvLiquidLensErrorCount_get, METH_O, "\n"
		"An integer property. This register increments whenever an error occurred while communicating with the Liquid Lens.\n"
		"This register increments whenever an error occurred while communicating with the Liquid Lens.\n"
		""},
	 { "mvSerialInterfaceControl_mvLiquidLensPowerMode_get", _wrap_mvSerialInterfaceControl_mvLiquidLensPowerMode_get, METH_O, "\n"
		"An enumerated integer property. Selects the device power mode.\n"
		"Selects the device power mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLiquidLensActive** (Display string: 'mv Liquid Lens Active'): Puts the device to power-active mode.\n"
		"- **mvLiquidLensStandby** (Display string: 'mv Liquid Lens Standby'): Puts the Liquid Lens in power-saving mode. In this mode the device will only consume up to 25 percent of its normal power consumption.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvSerialInterfaceControl_mvLiquidLensSetFocusValue_get", _wrap_mvSerialInterfaceControl_mvLiquidLensSetFocusValue_get, METH_O, "\n"
		"An integer property. Focus position value for Liquid Lens.\n"
		"Focus position value for Liquid Lens.\n"
		""},
	 { "mvSerialInterfaceControl_mvLiquidLensReceiveStatus_get", _wrap_mvSerialInterfaceControl_mvLiquidLensReceiveStatus_get, METH_O, "\n"
		"An integer property. Result of the serial receive error detection mechanism.\n"
		"Result of the serial receive error detection mechanism. This is a bit field. The bits have the following meaning: 0x1: CRC Error, 0x2: NAK received, 0x4: No response, 0x8 Incorrect answer received.\n"
		""},
	 { "mvSerialInterfaceControl_mvLiquidLensSaveFocusValue_get", _wrap_mvSerialInterfaceControl_mvLiquidLensSaveFocusValue_get, METH_O, "\n"
		"A method object. Saves the current Focus position into LiquidLens EEPROM.\n"
		"Saves the current Focus position into LiquidLens EEPROM.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperFirmwareVersion_get", _wrap_mvSerialInterfaceControl_mvStepperFirmwareVersion_get, METH_O, "\n"
		"An integer property. Returns the firmware version of the Opto Engineering Stepper.\n"
		"Returns the firmware version of the Opto Engineering Stepper.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperReceiveStatus_get", _wrap_mvSerialInterfaceControl_mvStepperReceiveStatus_get, METH_O, "\n"
		"An integer property. Result of the serial receive error detection mechanism.\n"
		"Result of the serial receive error detection mechanism. This is a bit field. The bits have the following meaning: 0x1: Reserved, 0x2: Mismatch in answer detected, 0x4: No response, 0x8 Incorrect answer received.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperErrorCount_get", _wrap_mvSerialInterfaceControl_mvStepperErrorCount_get, METH_O, "\n"
		"An integer property. This register increments whenever an error occurred while communicating with the Opto Engineering Stepper.\n"
		"This register increments whenever an error occurred while communicating with the Opto Engineering Stepper.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperAutoSavePositionEnable_get", _wrap_mvSerialInterfaceControl_mvStepperAutoSavePositionEnable_get, METH_O, "\n"
		"A boolean property. Controls if the auto-save of motor positions is active.\n"
		"Controls if the auto-save of motor positions is active.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperMotorSelector_get", _wrap_mvSerialInterfaceControl_mvStepperMotorSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the stepper motor to control.\n"
		"Selects the stepper motor to control(Zoom, Iris or Focus).\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **All** (Display string: 'All'): All stepper motors are selected.\n"
		"- **Zoom** (Display string: 'Zoom'): Selects the stepper motor controlling the zoom.\n"
		"- **Focus** (Display string: 'Focus'): Selects the stepper motor controlling the focus.\n"
		"- **Iris** (Display string: 'Iris'): Selects the stepper motor controlling the iris.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperStatus_get", _wrap_mvSerialInterfaceControl_mvStepperStatus_get, METH_O, "\n"
		"An enumerated integer property. Returns the current status of the stepper.\n"
		"Returns the current status of the stepper.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Unknown** (Display string: 'Unknown'): The current status of the stepper is unknown.\n"
		"- **Moving** (Display string: 'Moving'): The selected stepper motor is currently moving.\n"
		"- **StoppedAtLowerLimitWithTorque** (Display string: 'Stopped At Lower Limit With Torque'): The selected stepper motor has stopped at its lower limit with torque(this should never happen and indicates a problem).\n"
		"- **StoppedAtLowerLimit** (Display string: 'Stopped At Lower Limit'): The selected stepper motor has stopped at its lower limit.\n"
		"- **StoppedAtUpperLimitWithTorque** (Display string: 'Stopped At Upper Limit With Torque'): The selected stepper motor has stopped at its upper limit with torque(this should never happen and indicates a problem).\n"
		"- **StoppedAtUpperLimit** (Display string: 'Stopped At Upper Limit'): The selected stepper motor has stopped at its upper limit.\n"
		"- **StoppedWithTorque** (Display string: 'Stopped With Torque'): The selected stepper motor has stopped with torque(this should never happen and indicates a problem).\n"
		"- **Stopped** (Display string: 'Stopped'): The selected stepper motor has stopped.\n"
		"- **OvercurrentOrOvertemperatureError** (Display string: 'Overcurrent Or Overtemperature Error'): The selected stepper motor either became too hot or is taking in too much current(this should never happen and indicates a problem).\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperCurrentPosition_get", _wrap_mvSerialInterfaceControl_mvStepperCurrentPosition_get, METH_O, "\n"
		"An integer property. Read current position from stepper.\n"
		"Read current position from stepper.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperDesiredPosition_get", _wrap_mvSerialInterfaceControl_mvStepperDesiredPosition_get, METH_O, "\n"
		"An integer property. The desired position of the selected stepper motor.\n"
		"The desired position of the selected stepper motor. When the motor has not yet reached this position(is moving) this value may differ from 'mvStepperCurrentPosition'.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperSpeed_get", _wrap_mvSerialInterfaceControl_mvStepperSpeed_get, METH_O, "\n"
		"A floating point property. Current speed of the selected stepper motor.\n"
		"Current speed of the selected stepper motor.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperAcceleration_get", _wrap_mvSerialInterfaceControl_mvStepperAcceleration_get, METH_O, "\n"
		"A floating point property. Current acceleration of the selected stepper motor.\n"
		"Current acceleration of the selected stepper motor.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperSpeedManual_get", _wrap_mvSerialInterfaceControl_mvStepperSpeedManual_get, METH_O, "\n"
		"A floating point property. Manual speed of the selected stepper motor.\n"
		"Manual speed of the selected stepper motor.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperPositionSetSelector_get", _wrap_mvSerialInterfaceControl_mvStepperPositionSetSelector_get, METH_O, "\n"
		"An integer property. Selects the stepper parameter set to load or save.\n"
		"Selects the stepper parameter set to load or save.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperPositionSetLoad_get", _wrap_mvSerialInterfaceControl_mvStepperPositionSetLoad_get, METH_O, "\n"
		"A method object. Loads the stepper 'mvStepperDesiredPosition' specified by 'mvStepperPositionSetSelector' and makes it active for each motor.\n"
		"Loads the stepper 'mvStepperDesiredPosition' specified by 'mvStepperPositionSetSelector' and makes it active for each motor.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperPositionSetSave_get", _wrap_mvSerialInterfaceControl_mvStepperPositionSetSave_get, METH_O, "\n"
		"A method object. Saves the stepper 'mvStepperDesiredPosition' specified by 'mvStepperPositionSetSelector' into the steppers non-volatile memory for each motor.\n"
		"Saves the stepper 'mvStepperDesiredPosition' specified by 'mvStepperPositionSetSelector' into the steppers non-volatile memory for each motor.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperMoveToHomeAll_get", _wrap_mvSerialInterfaceControl_mvStepperMoveToHomeAll_get, METH_O, "\n"
		"A method object. Moves all stepper motors to their home position.\n"
		"Moves all stepper motors to their home position.\n"
		""},
	 { "mvSerialInterfaceControl_mvStepperStopAll_get", _wrap_mvSerialInterfaceControl_mvStepperStopAll_get, METH_O, "\n"
		"A method object. Stops all stepper motors.\n"
		"Stops all stepper motors.\n"
		""},
	 { "delete_mvSerialInterfaceControl", _wrap_delete_mvSerialInterfaceControl, METH_O, NULL},
	 { "mvSerialInterfaceControl_swigregister", mvSerialInterfaceControl_swigregister, METH_O, NULL},
	 { "mvSerialInterfaceControl_swiginit", mvSerialInterfaceControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvI2cInterfaceControl", _wrap_new_mvI2cInterfaceControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvI2cInterfaceControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceEnable_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceEnable_get, METH_O, "\n"
		"A boolean property. Controls whether the I2C interface is enabled or not.\n"
		"Controls whether the I2C interface is enabled or not.\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceDeviceAddress_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceDeviceAddress_get, METH_O, "\n"
		"An integer property. I2C device address, must be even.\n"
		"I2C device address, must be even, blocked addresses: 0x20, 0x30 (Test), 0x32, 0x34, 0x36, 0x3E, 0x60, 0x62, 0x64, 0x66, 0x6E, 0x90, 0x92, 0xA0, 0xA2, 0xA4, 0xA6, 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC, 0xBE.\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceDeviceSubAddress_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceDeviceSubAddress_get, METH_O, "\n"
		"An integer property. I2C device sub address ignored when set to -1, 2 byte address if bit 0x10000 is set, else 1 Byte.\n"
		"I2C device sub address ignored when set to -1, 2 byte address if bit 0x10000 is set, else 1 Byte.\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceASCIIBuffer_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceASCIIBuffer_get, METH_O, "\n"
		"A string property. Buffer for exchanging ASCII data over the I2C interface. This buffer uses the same memory as 'mvI2cInterfaceBinaryBuffer'.\n"
		"Buffer for exchanging ASCII data over the I2C interface. This buffer uses the same memory as 'mvI2cInterfaceBinaryBuffer'.\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceBinaryBuffer_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceBinaryBuffer_get, METH_O, "\n"
		"A string property. Buffer for exchanging binary data over the I2C interface. This buffer uses the same memory as 'mvI2cInterfaceASCIIBuffer'.\n"
		"Buffer for exchanging binary data over the I2C interface. This buffer uses the same memory as 'mvI2cInterfaceASCIIBuffer'.\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceBytesToWrite_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceBytesToWrite_get, METH_O, "\n"
		"An integer property. Number of bytes from mvI2cInterfaceBuffer to write to I2C device.\n"
		"Number of bytes from mvI2cInterfaceBuffer to write to I2C device.\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceBytesToRead_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceBytesToRead_get, METH_O, "\n"
		"An integer property. Number of bytes to read from I2C device.\n"
		"Number of bytes to read from I2C device.\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceRead_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceRead_get, METH_O, "\n"
		"A method object. Command to read data from I2C device.\n"
		"Command to read data from I2C device.\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceWrite_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceWrite_get, METH_O, "\n"
		"A method object. Command to write data to I2C device\n"
		"Command to write data to I2C device\n"
		""},
	 { "mvI2cInterfaceControl_mvI2cInterfaceSpeed_get", _wrap_mvI2cInterfaceControl_mvI2cInterfaceSpeed_get, METH_O, "\n"
		"An enumerated integer property. I2C interface clock frequency.\n"
		"I2C interface clock frequency.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **kHz_100** (Display string: '100 kHz'): default speed\n"
		"- **kHz_400** (Display string: '400 kHz'): fast speed\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_mvI2cInterfaceControl", _wrap_delete_mvI2cInterfaceControl, METH_O, NULL},
	 { "mvI2cInterfaceControl_swigregister", mvI2cInterfaceControl_swigregister, METH_O, NULL},
	 { "mvI2cInterfaceControl_swiginit", mvI2cInterfaceControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvLogicGateControl", _wrap_new_mvLogicGateControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvLogicGateControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvLogicGateControl_mvLogicGateANDSelector_get", _wrap_mvLogicGateControl_mvLogicGateANDSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the AND gate to configure.\n"
		"This enumeration selects the AND gate to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLogicGateAND1** (Display string: 'mv Logic Gate AND 1')\n"
		"- **mvLogicGateAND2** (Display string: 'mv Logic Gate AND 2')\n"
		"- **mvLogicGateAND3** (Display string: 'mv Logic Gate AND 3')\n"
		"- **mvLogicGateAND4** (Display string: 'mv Logic Gate AND 4')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateANDSource1_get", _wrap_mvLogicGateControl_mvLogicGateANDSource1_get, METH_O, "\n"
		"An enumerated integer property. Selects the first input signal of the AND gate selected by mvLogicGateANDSelector.\n"
		"This enumeration can be used to select the first input signal of the AND gate selected by mvLogicGateANDSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **Line4** (Display string: 'Line 4')\n"
		"- **Line5** (Display string: 'Line 5')\n"
		"- **Line6** (Display string: 'Line 6')\n"
		"- **Line7** (Display string: 'Line 7')\n"
		"- **Line12** (Display string: 'Line 12')\n"
		"- **Line13** (Display string: 'Line 13')\n"
		"- **Line14** (Display string: 'Line 14')\n"
		"- **Line15** (Display string: 'Line 15')\n"
		"- **ExposureActive** (Display string: 'Exposure Active')\n"
		"- **mvExposureSensor2Active** (Display string: 'mv Exposure Sensor 2 Active')\n"
		"- **UserOutput0** (Display string: 'User Output 0')\n"
		"- **UserOutput1** (Display string: 'User Output 1')\n"
		"- **UserOutput2** (Display string: 'User Output 2')\n"
		"- **UserOutput3** (Display string: 'User Output 3')\n"
		"- **UserOutput4** (Display string: 'User Output 4')\n"
		"- **UserOutput5** (Display string: 'User Output 5')\n"
		"- **UserOutput6** (Display string: 'User Output 6')\n"
		"- **UserOutput7** (Display string: 'User Output 7')\n"
		"- **Timer1Active** (Display string: 'Timer 1 Active')\n"
		"- **Timer2Active** (Display string: 'Timer 2 Active')\n"
		"- **Timer3Active** (Display string: 'Timer 3 Active')\n"
		"- **Counter1Active** (Display string: 'Counter 1 Active')\n"
		"- **Counter2Active** (Display string: 'Counter 2 Active')\n"
		"- **Counter3Active** (Display string: 'Counter 3 Active')\n"
		"- **Counter4Active** (Display string: 'Counter 4 Active')\n"
		"- **Counter5Active** (Display string: 'Counter 5 Active')\n"
		"- **Counter6Active** (Display string: 'Counter 6 Active')\n"
		"- **Counter7Active** (Display string: 'Counter 7 Active')\n"
		"- **Counter8Active** (Display string: 'Counter 8 Active')\n"
		"- **AcquisitionActive** (Display string: 'Acquisition Active')\n"
		"- **FrameActive** (Display string: 'Frame Active')\n"
		"- **LineActive** (Display string: 'Line Active')\n"
		"- **FrameTriggerWait** (Display string: 'Frame Trigger Wait')\n"
		"- **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')\n"
		"- **mvExposureActive** (Display string: 'mv Exposure Active')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvANDSource1Inverter_get", _wrap_mvLogicGateControl_mvANDSource1Inverter_get, METH_O, "\n"
		"A boolean property. Inverts the first input signal of the AND gate selected by mvLogicGateANDSelector\n"
		"Inverts the first input signal of the AND gate selected by mvLogicGateANDSelector\n"
		""},
	 { "mvLogicGateControl_mvLogicGateANDSource2_get", _wrap_mvLogicGateControl_mvLogicGateANDSource2_get, METH_O, "\n"
		"An enumerated integer property. Selects the second input signal of the AND gate selected by mvLogicGateANDSelector.\n"
		"This enumeration can be used to select the second input signal of the AND gate selected by mvLogicGateANDSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **Line4** (Display string: 'Line 4')\n"
		"- **Line5** (Display string: 'Line 5')\n"
		"- **Line6** (Display string: 'Line 6')\n"
		"- **Line7** (Display string: 'Line 7')\n"
		"- **Line12** (Display string: 'Line 12')\n"
		"- **Line13** (Display string: 'Line 13')\n"
		"- **Line14** (Display string: 'Line 14')\n"
		"- **Line15** (Display string: 'Line 15')\n"
		"- **ExposureActive** (Display string: 'Exposure Active')\n"
		"- **mvExposureSensor2Active** (Display string: 'mv Exposure Sensor 2 Active')\n"
		"- **UserOutput0** (Display string: 'User Output 0')\n"
		"- **UserOutput1** (Display string: 'User Output 1')\n"
		"- **UserOutput2** (Display string: 'User Output 2')\n"
		"- **UserOutput3** (Display string: 'User Output 3')\n"
		"- **UserOutput4** (Display string: 'User Output 4')\n"
		"- **UserOutput5** (Display string: 'User Output 5')\n"
		"- **UserOutput6** (Display string: 'User Output 6')\n"
		"- **UserOutput7** (Display string: 'User Output 7')\n"
		"- **Timer1Active** (Display string: 'Timer 1 Active')\n"
		"- **Timer2Active** (Display string: 'Timer 2 Active')\n"
		"- **Timer3Active** (Display string: 'Timer 3 Active')\n"
		"- **Counter1Active** (Display string: 'Counter 1 Active')\n"
		"- **Counter2Active** (Display string: 'Counter 2 Active')\n"
		"- **Counter3Active** (Display string: 'Counter 3 Active')\n"
		"- **Counter4Active** (Display string: 'Counter 4 Active')\n"
		"- **Counter5Active** (Display string: 'Counter 5 Active')\n"
		"- **Counter6Active** (Display string: 'Counter 6 Active')\n"
		"- **Counter7Active** (Display string: 'Counter 7 Active')\n"
		"- **Counter8Active** (Display string: 'Counter 8 Active')\n"
		"- **AcquisitionActive** (Display string: 'Acquisition Active')\n"
		"- **FrameActive** (Display string: 'Frame Active')\n"
		"- **LineActive** (Display string: 'Line Active')\n"
		"- **FrameTriggerWait** (Display string: 'Frame Trigger Wait')\n"
		"- **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')\n"
		"- **mvExposureActive** (Display string: 'mv Exposure Active')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvANDSource2Inverter_get", _wrap_mvLogicGateControl_mvANDSource2Inverter_get, METH_O, "\n"
		"A boolean property. Inverts the second input signal of the AND gate selected by mvLogicGateANDSelector\n"
		"Inverts the second input signal of the AND gate selected by mvLogicGateANDSelector\n"
		""},
	 { "mvLogicGateControl_mvLogicGateORSelector_get", _wrap_mvLogicGateControl_mvLogicGateORSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the OR gate to configure.\n"
		"This enumeration selects the OR gate to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLogicGateOR1** (Display string: 'mv Logic Gate OR 1')\n"
		"- **mvLogicGateOR2** (Display string: 'mv Logic Gate OR 2')\n"
		"- **mvLogicGateOR3** (Display string: 'mv Logic Gate OR 3')\n"
		"- **mvLogicGateOR4** (Display string: 'mv Logic Gate OR 4')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateORSource1_get", _wrap_mvLogicGateControl_mvLogicGateORSource1_get, METH_O, "\n"
		"An enumerated integer property. Selects the first input signal of the OR gate selected by mvLogicGateORSelector.\n"
		"This enumeration can be used to select the first input signal of the OR gate selected by mvLogicGateORSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLogicGateAND1Output** (Display string: 'mv Logic Gate AND 1 Output')\n"
		"- **mvLogicGateAND2Output** (Display string: 'mv Logic Gate AND 2 Output')\n"
		"- **mvLogicGateAND3Output** (Display string: 'mv Logic Gate AND 3 Output')\n"
		"- **mvLogicGateAND4Output** (Display string: 'mv Logic Gate AND 4 Output')\n"
		"- **Off** (Display string: 'Off')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateORSource2_get", _wrap_mvLogicGateControl_mvLogicGateORSource2_get, METH_O, "\n"
		"An enumerated integer property. Selects the second input signal of the OR gate selected by mvLogicGateORSelector.\n"
		"This enumeration can be used to select the second input signal of the OR gate selected by mvLogicGateORSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLogicGateAND1Output** (Display string: 'mv Logic Gate AND 1 Output')\n"
		"- **mvLogicGateAND2Output** (Display string: 'mv Logic Gate AND 2 Output')\n"
		"- **mvLogicGateAND3Output** (Display string: 'mv Logic Gate AND 3 Output')\n"
		"- **mvLogicGateAND4Output** (Display string: 'mv Logic Gate AND 4 Output')\n"
		"- **Off** (Display string: 'Off')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateORSource3_get", _wrap_mvLogicGateControl_mvLogicGateORSource3_get, METH_O, "\n"
		"An enumerated integer property. Selects the third input signal of the OR gate selected by mvLogicGateORSelector.\n"
		"This enumeration can be used to select the third input signal of the OR gate selected by mvLogicGateORSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLogicGateAND1Output** (Display string: 'mv Logic Gate AND 1 Output')\n"
		"- **mvLogicGateAND2Output** (Display string: 'mv Logic Gate AND 2 Output')\n"
		"- **mvLogicGateAND3Output** (Display string: 'mv Logic Gate AND 3 Output')\n"
		"- **mvLogicGateAND4Output** (Display string: 'mv Logic Gate AND 4 Output')\n"
		"- **Off** (Display string: 'Off')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateORSource4_get", _wrap_mvLogicGateControl_mvLogicGateORSource4_get, METH_O, "\n"
		"An enumerated integer property. Selects the fourth input signal of the OR gate selected by mvLogicGateORSelector.\n"
		"This enumeration can be used to select the fourth input signal of the OR gate selected by mvLogicGateORSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLogicGateAND1Output** (Display string: 'mv Logic Gate AND 1 Output')\n"
		"- **mvLogicGateAND2Output** (Display string: 'mv Logic Gate AND 2 Output')\n"
		"- **mvLogicGateAND3Output** (Display string: 'mv Logic Gate AND 3 Output')\n"
		"- **mvLogicGateAND4Output** (Display string: 'mv Logic Gate AND 4 Output')\n"
		"- **Off** (Display string: 'Off')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateSourceSelector_get", _wrap_mvLogicGateControl_mvLogicGateSourceSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the LogicGateSource of the AND-OR-Matrix.\n"
		"Selects the LogicGateSource of the AND-OR-Matrix.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLogicGateSource0** (Display string: 'mv Logic Gate Source 0')\n"
		"- **mvLogicGateSource1** (Display string: 'mv Logic Gate Source 1')\n"
		"- **mvLogicGateSource2** (Display string: 'mv Logic Gate Source 2')\n"
		"- **mvLogicGateSource3** (Display string: 'mv Logic Gate Source 3')\n"
		"- **mvLogicGateSource4** (Display string: 'mv Logic Gate Source 4')\n"
		"- **mvLogicGateSource5** (Display string: 'mv Logic Gate Source 5')\n"
		"- **mvLogicGateSource6** (Display string: 'mv Logic Gate Source 6')\n"
		"- **mvLogicGateSource7** (Display string: 'mv Logic Gate Source 7')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateSource_get", _wrap_mvLogicGateControl_mvLogicGateSource_get, METH_O, "\n"
		"An enumerated integer property. Selects the input signal of the AND-OR-Matrix selected by mvLogicGateSourceSelector.\n"
		"Selects the input signal of the AND-OR-Matrix selected by mvLogicGateSourceSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **Line4** (Display string: 'Line 4')\n"
		"- **Line5** (Display string: 'Line 5')\n"
		"- **Line6** (Display string: 'Line 6')\n"
		"- **Line7** (Display string: 'Line 7')\n"
		"- **ExposureActive** (Display string: 'Exposure Active')\n"
		"- **mvExposureSensor2Active** (Display string: 'mv Exposure Sensor 2 Active')\n"
		"- **UserOutput0** (Display string: 'User Output 0')\n"
		"- **UserOutput1** (Display string: 'User Output 1')\n"
		"- **UserOutput2** (Display string: 'User Output 2')\n"
		"- **UserOutput3** (Display string: 'User Output 3')\n"
		"- **UserOutput4** (Display string: 'User Output 4')\n"
		"- **UserOutput5** (Display string: 'User Output 5')\n"
		"- **UserOutput6** (Display string: 'User Output 6')\n"
		"- **UserOutput7** (Display string: 'User Output 7')\n"
		"- **Timer1Active** (Display string: 'Timer 1 Active')\n"
		"- **Timer2Active** (Display string: 'Timer 2 Active')\n"
		"- **Timer3Active** (Display string: 'Timer 3 Active')\n"
		"- **Counter1Active** (Display string: 'Counter 1 Active')\n"
		"- **Counter2Active** (Display string: 'Counter 2 Active')\n"
		"- **Counter3Active** (Display string: 'Counter 3 Active')\n"
		"- **Counter4Active** (Display string: 'Counter 4 Active')\n"
		"- **Counter5Active** (Display string: 'Counter 5 Active')\n"
		"- **Counter6Active** (Display string: 'Counter 6 Active')\n"
		"- **Counter7Active** (Display string: 'Counter 7 Active')\n"
		"- **Counter8Active** (Display string: 'Counter 8 Active')\n"
		"- **AcquisitionActive** (Display string: 'Acquisition Active')\n"
		"- **FrameActive** (Display string: 'Frame Active')\n"
		"- **LineActive** (Display string: 'Line Active')\n"
		"- **FrameTriggerWait** (Display string: 'Frame Trigger Wait')\n"
		"- **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')\n"
		"- **mvExposureActive** (Display string: 'mv Exposure Active')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateSourceInverter_get", _wrap_mvLogicGateControl_mvLogicGateSourceInverter_get, METH_O, "\n"
		"A boolean property. Inverts the input signal.\n"
		"Inverts the input signal.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateANDTermSelector_get", _wrap_mvLogicGateControl_mvLogicGateANDTermSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the AND-term of the AND-OR-matrix.\n"
		"Selects the AND-term of the AND-OR-matrix.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLogicGateANDTerm0** (Display string: 'mv Logic Gate AND Term 0')\n"
		"- **mvLogicGateANDTerm1** (Display string: 'mv Logic Gate AND Term 1')\n"
		"- **mvLogicGateANDTerm2** (Display string: 'mv Logic Gate AND Term 2')\n"
		"- **mvLogicGateANDTerm3** (Display string: 'mv Logic Gate AND Term 3')\n"
		"- **mvLogicGateANDTerm4** (Display string: 'mv Logic Gate AND Term 4')\n"
		"- **mvLogicGateANDTerm5** (Display string: 'mv Logic Gate AND Term 5')\n"
		"- **mvLogicGateANDTerm6** (Display string: 'mv Logic Gate AND Term 6')\n"
		"- **mvLogicGateANDTerm7** (Display string: 'mv Logic Gate AND Term 7')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateANDTermSrc0_get", _wrap_mvLogicGateControl_mvLogicGateANDTermSrc0_get, METH_O, "\n"
		"An enumerated integer property. Selects the first input signal of the AND-term selected by mvLogicGateANDTermSelector.\n"
		"Selects the first input signal of the AND-term selected by mvLogicGateANDTermSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **mvLogicGateSource0** (Display string: 'mv Logic Gate Source 0')\n"
		"- **mvLogicGateSource1** (Display string: 'mv Logic Gate Source 1')\n"
		"- **mvLogicGateSource2** (Display string: 'mv Logic Gate Source 2')\n"
		"- **mvLogicGateSource3** (Display string: 'mv Logic Gate Source 3')\n"
		"- **mvLogicGateSource4** (Display string: 'mv Logic Gate Source 4')\n"
		"- **mvLogicGateSource5** (Display string: 'mv Logic Gate Source 5')\n"
		"- **mvLogicGateSource6** (Display string: 'mv Logic Gate Source 6')\n"
		"- **mvLogicGateSource7** (Display string: 'mv Logic Gate Source 7')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateANDTermSrc1_get", _wrap_mvLogicGateControl_mvLogicGateANDTermSrc1_get, METH_O, "\n"
		"An enumerated integer property. Selects the second input signal of the AND-term selected by mvLogicGateANDTermSelector.\n"
		"Selects the second input signal of the AND-term selected by mvLogicGateANDTermSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **mvLogicGateSource0** (Display string: 'mv Logic Gate Source 0')\n"
		"- **mvLogicGateSource1** (Display string: 'mv Logic Gate Source 1')\n"
		"- **mvLogicGateSource2** (Display string: 'mv Logic Gate Source 2')\n"
		"- **mvLogicGateSource3** (Display string: 'mv Logic Gate Source 3')\n"
		"- **mvLogicGateSource4** (Display string: 'mv Logic Gate Source 4')\n"
		"- **mvLogicGateSource5** (Display string: 'mv Logic Gate Source 5')\n"
		"- **mvLogicGateSource6** (Display string: 'mv Logic Gate Source 6')\n"
		"- **mvLogicGateSource7** (Display string: 'mv Logic Gate Source 7')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateORTermSelector_get", _wrap_mvLogicGateControl_mvLogicGateORTermSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the OR-term of the AND-OR-matrix.\n"
		"Selects the OR-term of the AND-OR-matrix.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLogicGateORTerm0** (Display string: 'mv Logic Gate OR Term 0')\n"
		"- **mvLogicGateORTerm1** (Display string: 'mv Logic Gate OR Term 1')\n"
		"- **mvLogicGateORTerm2** (Display string: 'mv Logic Gate OR Term 2')\n"
		"- **mvLogicGateORTerm3** (Display string: 'mv Logic Gate OR Term 3')\n"
		"- **mvLogicGateORTerm4** (Display string: 'mv Logic Gate OR Term 4')\n"
		"- **mvLogicGateORTerm5** (Display string: 'mv Logic Gate OR Term 5')\n"
		"- **mvLogicGateORTerm6** (Display string: 'mv Logic Gate OR Term 6')\n"
		"- **mvLogicGateORTerm7** (Display string: 'mv Logic Gate OR Term 7')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateORTermSrc0_get", _wrap_mvLogicGateControl_mvLogicGateORTermSrc0_get, METH_O, "\n"
		"An enumerated integer property. Selects the first input signal of the ORTerm selected by mvLogicGateORTermSelector.\n"
		"Selects the first input signal of the ORTerm selected by mvLogicGateORTermSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **mvLogicGateANDTerm0** (Display string: 'mv Logic Gate AND Term 0')\n"
		"- **mvLogicGateANDTerm1** (Display string: 'mv Logic Gate AND Term 1')\n"
		"- **mvLogicGateANDTerm2** (Display string: 'mv Logic Gate AND Term 2')\n"
		"- **mvLogicGateANDTerm3** (Display string: 'mv Logic Gate AND Term 3')\n"
		"- **mvLogicGateANDTerm4** (Display string: 'mv Logic Gate AND Term 4')\n"
		"- **mvLogicGateANDTerm5** (Display string: 'mv Logic Gate AND Term 5')\n"
		"- **mvLogicGateANDTerm6** (Display string: 'mv Logic Gate AND Term 6')\n"
		"- **mvLogicGateANDTerm7** (Display string: 'mv Logic Gate AND Term 7')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLogicGateControl_mvLogicGateORTermSrc1_get", _wrap_mvLogicGateControl_mvLogicGateORTermSrc1_get, METH_O, "\n"
		"An enumerated integer property. Selects the second input signal of the ORTerm selected by mvLogicGateORTermSelector.\n"
		"Selects the second input signal of the ORTerm selected by mvLogicGateORTermSelector.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off')\n"
		"- **mvLogicGateANDTerm0** (Display string: 'mv Logic Gate AND Term 0')\n"
		"- **mvLogicGateANDTerm1** (Display string: 'mv Logic Gate AND Term 1')\n"
		"- **mvLogicGateANDTerm2** (Display string: 'mv Logic Gate AND Term 2')\n"
		"- **mvLogicGateANDTerm3** (Display string: 'mv Logic Gate AND Term 3')\n"
		"- **mvLogicGateANDTerm4** (Display string: 'mv Logic Gate AND Term 4')\n"
		"- **mvLogicGateANDTerm5** (Display string: 'mv Logic Gate AND Term 5')\n"
		"- **mvLogicGateANDTerm6** (Display string: 'mv Logic Gate AND Term 6')\n"
		"- **mvLogicGateANDTerm7** (Display string: 'mv Logic Gate AND Term 7')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_mvLogicGateControl", _wrap_delete_mvLogicGateControl, METH_O, NULL},
	 { "mvLogicGateControl_swigregister", mvLogicGateControl_swigregister, METH_O, NULL},
	 { "mvLogicGateControl_swiginit", mvLogicGateControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvCurrentControl", _wrap_new_mvCurrentControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvCurrentControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvCurrentControl_mvCurrentSelector_get", _wrap_mvCurrentControl_mvCurrentSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the current source to configure.\n"
		"Selects the current source to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Current0** (Display string: 'Current 0')\n"
		"- **Current1** (Display string: 'Current 1')\n"
		"- **Current2** (Display string: 'Current 2')\n"
		"- **Current3** (Display string: 'Current 3')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvCurrentControl_mvCurrent_get", _wrap_mvCurrentControl_mvCurrent_get, METH_O, "\n"
		"An integer property. Sets the current value for the selected device(e.g.: LED).\n"
		"Sets the current value for the selected device(e.g.: LED).\n"
		""},
	 { "delete_mvCurrentControl", _wrap_delete_mvCurrentControl, METH_O, NULL},
	 { "mvCurrentControl_swigregister", mvCurrentControl_swigregister, METH_O, NULL},
	 { "mvCurrentControl_swiginit", mvCurrentControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvLensControl", _wrap_new_mvLensControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvLensControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvLensControl_mvIrisType_get", _wrap_mvLensControl_mvIrisType_get, METH_O, "\n"
		"An enumerated integer property. Sets the iris type.\n"
		"Sets the iris type.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvVideoIris** (Display string: 'mv Video Iris')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLensControl_mvIrisMode_get", _wrap_mvLensControl_mvIrisMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the iris operating mode.\n"
		"Sets the iris operating mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): No iris adjustment will be done.\n"
		"- **mvIrisAuto** (Display string: 'mv Iris Auto'): The iris adjustment will be done automatically by evaluating the current image data.\n"
		"- **mvIrisOpen** (Display string: 'mv Iris Open'): The iris is fully open.\n"
		"- **mvIrisClose** (Display string: 'mv Iris Close'): The iris is fully closed.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLensControl_mvIrisSignalLevelMin_get", _wrap_mvLensControl_mvIrisSignalLevelMin_get, METH_O, "\n"
		"An integer property. Sets the minimum iris signal level in mV.\n"
		"Sets the minimum iris signal level in mV.\n"
		""},
	 { "mvLensControl_mvIrisSignalLevelMax_get", _wrap_mvLensControl_mvIrisSignalLevelMax_get, METH_O, "\n"
		"An integer property. Sets the maximum iris signal level in mV.\n"
		"Sets the maximum iris signal level in mV.\n"
		""},
	 { "mvLensControl_mvDriveSelector_get", _wrap_mvLensControl_mvDriveSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the lens drive that should be adjusted.\n"
		"Selects the lens drive that should be adjusted.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvFocus** (Display string: 'mv Focus'): Selects the motor to control the focus.\n"
		"- **mvZoom** (Display string: 'mv Zoom'): Selects the motor to control the zoom.\n"
		"- **mvIris** (Display string: 'mv Iris'): Selects the motor to control the iris.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvLensControl_mvDriveForward_get", _wrap_mvLensControl_mvDriveForward_get, METH_O, "\n"
		"A method object. Generates a pulse defined by 'mvDriveDuration' and 'mvDriveLevel' to move the selected motor in forward direction.\n"
		"Generates a pulse defined by 'mvDriveDuration' and 'mvDriveLevel' to move the selected motor in forward direction.\n"
		""},
	 { "mvLensControl_mvDriveBackward_get", _wrap_mvLensControl_mvDriveBackward_get, METH_O, "\n"
		"A method object. Generates a pulse defined by 'mvDriveDuration' and 'mvDriveLevel' to move the selected motor in backward direction.\n"
		"Generates a pulse defined by 'mvDriveDuration' and 'mvDriveLevel' to move the selected motor in backward direction.\n"
		""},
	 { "mvLensControl_mvDriveDuration_get", _wrap_mvLensControl_mvDriveDuration_get, METH_O, "\n"
		"An integer property. Sets the duration of the drive command in us.\n"
		"Sets the duration of the drive command in us.\n"
		""},
	 { "mvLensControl_mvDriveLevel_get", _wrap_mvLensControl_mvDriveLevel_get, METH_O, "\n"
		"An integer property. Sets the voltage level of the drive command in mV.\n"
		"Sets the voltage level of the drive command in mV.\n"
		""},
	 { "delete_mvLensControl", _wrap_delete_mvLensControl, METH_O, NULL},
	 { "mvLensControl_swigregister", mvLensControl_swigregister, METH_O, NULL},
	 { "mvLensControl_swiginit", mvLensControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvFFCControl", _wrap_new_mvFFCControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvFFCControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvFFCControl_mvFFCEnable_get", _wrap_mvFFCControl_mvFFCEnable_get, METH_O, "\n"
		"A boolean property. Enables the Flat Field Correction.\n"
		"Enables the Flat Field Correction.\n"
		""},
	 { "mvFFCControl_mvFFCCalibrationImageCount_get", _wrap_mvFFCControl_mvFFCCalibrationImageCount_get, METH_O, "\n"
		"An integer property. The number of images to use for the calculation of the correction image.\n"
		"The number of images to use for the calculation of the correction image.\n"
		""},
	 { "mvFFCControl_mvFFCCalibrate_get", _wrap_mvFFCControl_mvFFCCalibrate_get, METH_O, "\n"
		"A method object. Starts the Calibration of the Flat Field Correction.\n"
		"Starts the Calibration of the Flat Field Correction.\n"
		""},
	 { "mvFFCControl_mvFFCImageLoad_get", _wrap_mvFFCControl_mvFFCImageLoad_get, METH_O, "\n"
		"A method object. Loads the Flat Field Correction image from flash.\n"
		"Loads the Flat Field Correction image from flash.\n"
		""},
	 { "mvFFCControl_mvFFCImageSave_get", _wrap_mvFFCControl_mvFFCImageSave_get, METH_O, "\n"
		"A method object. Saves the calibrated Flat Field Correction image to flash.\n"
		"Saves the calibrated Flat Field Correction image to flash.\n"
		""},
	 { "mvFFCControl_mvFFCAutoLoadMode_get", _wrap_mvFFCControl_mvFFCAutoLoadMode_get, METH_O, "\n"
		"An enumerated integer property. Selects whether FFC image shall be automatically loaded at camera startup.\n"
		"Selects whether FFC image shall be automatically loaded at camera startup.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvLegacy** (Display string: 'mv Legacy'): FFC image will be automatically loaded and saved after calibration. Should no longer be used. Be careful that You do not lose calibrated FFC images(deprecated)\n"
		"- **Off** (Display string: 'Off'): FFC image will not be automatically loaded at startup. Use this for short boot times.\n"
		"- **On** (Display string: 'On'): FFC image will be automatically loaded at startup. Boot time will increase accordingly.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_mvFFCControl", _wrap_delete_mvFFCControl, METH_O, NULL},
	 { "mvFFCControl_swigregister", mvFFCControl_swigregister, METH_O, NULL},
	 { "mvFFCControl_swiginit", mvFFCControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvFrameAverageControl", _wrap_new_mvFrameAverageControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvFrameAverageControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvFrameAverageControl_mvFrameAverageMode_get", _wrap_mvFrameAverageControl_mvFrameAverageMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the frame average operating mode.\n"
		"Sets the frame average operating mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvPlain** (Display string: 'mv Plain')\n"
		"- **mvDynamic** (Display string: 'mv Dynamic')\n"
		"- **mvNTo1** (Display string: 'mv N To 1')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvFrameAverageControl_mvFrameAverageEnable_get", _wrap_mvFrameAverageControl_mvFrameAverageEnable_get, METH_O, "\n"
		"A boolean property. Enables the frame averaging engine.\n"
		"Enables the frame averaging engine.\n"
		""},
	 { "mvFrameAverageControl_mvFrameAverageSlope_get", _wrap_mvFrameAverageControl_mvFrameAverageSlope_get, METH_O, "\n"
		"An integer property. Here you specify the noise border for very dark pictures.\n"
		"Here you specify the noise border for very dark pictures.\n"
		""},
	 { "mvFrameAverageControl_mvFrameAverageDynamicMode_get", _wrap_mvFrameAverageControl_mvFrameAverageDynamicMode_get, METH_O, "\n"
		"An enumerated integer property. Sets the frame average dynamic operating mode.\n"
		"Sets the frame average dynamic operating mode.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvStandard** (Display string: 'mv Standard')\n"
		"- **mvGauss** (Display string: 'mv Gauss')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvFrameAverageControl_mvFrameAverageNoiseLimit_get", _wrap_mvFrameAverageControl_mvFrameAverageNoiseLimit_get, METH_O, "\n"
		"An integer property. Here you specify the noise limit for very bright pictures.\n"
		"Here you specify the noise limit for very bright pictures.\n"
		""},
	 { "mvFrameAverageControl_mvFrameAverageNoiseGain_get", _wrap_mvFrameAverageControl_mvFrameAverageNoiseGain_get, METH_O, "\n"
		"An integer property. Here you specify the noise border for very bright pictures.\n"
		"Here you specify the noise border for very bright pictures.\n"
		""},
	 { "mvFrameAverageControl_mvFrameAverageFrameCount_get", _wrap_mvFrameAverageControl_mvFrameAverageFrameCount_get, METH_O, "\n"
		"An integer property. Here you specify the frame count used for the calculation of the frame average.\n"
		"Here you specify the frame count used for the calculation of the frame average.\n"
		""},
	 { "delete_mvFrameAverageControl", _wrap_delete_mvFrameAverageControl, METH_O, NULL},
	 { "mvFrameAverageControl_swigregister", mvFrameAverageControl_swigregister, METH_O, NULL},
	 { "mvFrameAverageControl_swiginit", mvFrameAverageControl_swiginit, METH_VARARGS, NULL},
	 { "new_mvHDRControl", _wrap_new_mvHDRControl, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::mvHDRControl** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "mvHDRControl_mvHDREnable_get", _wrap_mvHDRControl_mvHDREnable_get, METH_O, "\n"
		"A boolean property. Enables the High Dynamic Range Feature.\n"
		"Enables the High Dynamic Range Feature.\n"
		""},
	 { "mvHDRControl_mvHDRPreset_get", _wrap_mvHDRControl_mvHDRPreset_get, METH_O, "\n"
		"An enumerated integer property. Selects the HDR parameter set.\n"
		"Selects the HDR parameter set.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvDualKneePoint0** (Display string: 'mv Dual Knee Point 0')\n"
		"- **mvDualKneePoint1** (Display string: 'mv Dual Knee Point 1')\n"
		"- **mvDualKneePoint2** (Display string: 'mv Dual Knee Point 2')\n"
		"- **mvDualKneePoint3** (Display string: 'mv Dual Knee Point 3')\n"
		"- **mvDualKneePoint4** (Display string: 'mv Dual Knee Point 4')\n"
		"- **mvDualKneePoint5** (Display string: 'mv Dual Knee Point 5')\n"
		"- **mvDualKneePoint6** (Display string: 'mv Dual Knee Point 6')\n"
		"- **mvDualKneePointUser** (Display string: 'mv Dual Knee Point User')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvHDRControl_mvHDRSelector_get", _wrap_mvHDRControl_mvHDRSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the HDR parameter set to configure.\n"
		"This enumeration selects the HDR parameter set to configure.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvDualKneePoint0** (Display string: 'mv Dual Knee Point 0')\n"
		"- **mvDualKneePoint1** (Display string: 'mv Dual Knee Point 1')\n"
		"- **mvDualKneePoint2** (Display string: 'mv Dual Knee Point 2')\n"
		"- **mvDualKneePoint3** (Display string: 'mv Dual Knee Point 3')\n"
		"- **mvDualKneePoint4** (Display string: 'mv Dual Knee Point 4')\n"
		"- **mvDualKneePoint5** (Display string: 'mv Dual Knee Point 5')\n"
		"- **mvDualKneePoint6** (Display string: 'mv Dual Knee Point 6')\n"
		"- **mvDualKneePointUser** (Display string: 'mv Dual Knee Point User')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvHDRControl_mvHDRVoltage1_get", _wrap_mvHDRControl_mvHDRVoltage1_get, METH_O, "\n"
		"An integer property. First HDR Voltage in mV.\n"
		"First HDR Voltage in mV.\n"
		""},
	 { "mvHDRControl_mvHDRVoltage2_get", _wrap_mvHDRControl_mvHDRVoltage2_get, METH_O, "\n"
		"An integer property. Second HDR Voltage in mV.\n"
		"Second HDR Voltage in mV.\n"
		""},
	 { "mvHDRControl_mvHDRExposure1_get", _wrap_mvHDRControl_mvHDRExposure1_get, METH_O, "\n"
		"An integer property. First HDR Exposure in ppm.\n"
		"First HDR Exposure in ppm.\n"
		""},
	 { "mvHDRControl_mvHDRExposure2_get", _wrap_mvHDRControl_mvHDRExposure2_get, METH_O, "\n"
		"An integer property. Second HDR Exposure in ppm.\n"
		"Second HDR Exposure in ppm.\n"
		""},
	 { "mvHDRControl_mvHDRExposureRatio_get", _wrap_mvHDRControl_mvHDRExposureRatio_get, METH_O, "\n"
		"An enumerated integer property. T1/T2 Exposure Ratio\n"
		"The ratio of the long exposure time to the short exposure time.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvRatio4x** (Display string: 'mv Ratio 4x')\n"
		"- **mvRatio8x** (Display string: 'mv Ratio 8x')\n"
		"- **mvRatio16x** (Display string: 'mv Ratio 16x')\n"
		"- **mvRatio32x** (Display string: 'mv Ratio 32x')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "mvHDRControl_mvHDRMotionCompensationEnable_get", _wrap_mvHDRControl_mvHDRMotionCompensationEnable_get, METH_O, "\n"
		"A boolean property. Enables motion compensation\n"
		"Enables motion compensation. Recommended for scenes with a lot of motion.\n"
		""},
	 { "mvHDRControl_mvHDRAdaptiveLocalToneMappingEnable_get", _wrap_mvHDRControl_mvHDRAdaptiveLocalToneMappingEnable_get, METH_O, "\n"
		"A boolean property. Enables Adaptive Local Tone Mapping\n"
		"Enables Adaptive Local Tone Mapping. Recommended if mvHDRMotionCompensationEnable is enabled.\n"
		""},
	 { "delete_mvHDRControl", _wrap_delete_mvHDRControl, METH_O, NULL},
	 { "mvHDRControl_swigregister", mvHDRControl_swigregister, METH_O, NULL},
	 { "mvHDRControl_swiginit", mvHDRControl_swiginit, METH_VARARGS, NULL},
	 { "new_SystemModule", _wrap_new_SystemModule, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::SystemModule** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type index: int\n"
		":param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::SystemModule** object.\n"
		" Since: 2.17.0\n"
		"\n"
		":type index: int\n"
		":param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::SystemModule** object.\n"
		" Since: 2.17.0\n"
		"\n"
		":param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.\n"
		""},
	 { "SystemModule_TLVendorName_get", _wrap_SystemModule_TLVendorName_get, METH_O, "\n"
		"A string property. Indicates the name of the transport layer vendor.\n"
		"This is a read only element. It is a string that indicates the name of the transport layer vendor.\n"
		""},
	 { "SystemModule_TLModelName_get", _wrap_SystemModule_TLModelName_get, METH_O, "\n"
		"A string property. Indicates the name of the transport layer Model.\n"
		"This is a read only element. It is a string that indicates the name of the transport layer Model to distinguish different kinds of GenTL Producer implementations from one vendor.\n"
		""},
	 { "SystemModule_TLID_get", _wrap_SystemModule_TLID_get, METH_O, "\n"
		"A string property. Indicates the ID of the transport layer.\n"
		"This is a read only element. It is a string that indicates the ID of the transport layer.\n"
		""},
	 { "SystemModule_TLVersion_get", _wrap_SystemModule_TLVersion_get, METH_O, "\n"
		"A string property. Indicates a vendor specific version string for this transport layer.\n"
		"This is a read only element. It is a string that indicates a vendor specific version string for this transport layer.\n"
		""},
	 { "SystemModule_TLFileName_get", _wrap_SystemModule_TLFileName_get, METH_O, "\n"
		"A string property. Indicates the file name of the GenTL Producer driver including name and extension.\n"
		"This is a read only element. It is a string that indicates the file name of the GenTL Producer driver including name and extension.\n"
		""},
	 { "SystemModule_TLDisplayName_get", _wrap_SystemModule_TLDisplayName_get, METH_O, "\n"
		"A string property. User readable name of the GenTL Producer.\n"
		"This is a read only element. It is a string that indicates a user readable name of the GenTL Producer.\n"
		""},
	 { "SystemModule_TLPath_get", _wrap_SystemModule_TLPath_get, METH_O, "\n"
		"A string property. Indicates the full path to the GenTL Producer driver including name and extension.\n"
		"This is a read only element. It is a string that indicates the full path to the GenTL Producer driver including name and extension.\n"
		""},
	 { "SystemModule_TLType_get", _wrap_SystemModule_TLType_get, METH_O, "\n"
		"An enumerated integer property. Identifies the transport layer technology of the GenTL Producer implementation.\n"
		"This is a read only feature. This enumeration provides a value that indicates the transport layer technology of the GenTL Producer implementation.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a transport layer for a mixed protocol.\n"
		"- **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a transport layer for a custom protocol.\n"
		"- **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a transport layer for the GigE Vision protocol.\n"
		"- **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a transport layer for the CameraLink protocol.\n"
		"- **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a transport layer for the CoaXPress protocol.\n"
		"- **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a transport layer for the CameraLink HS protocol.\n"
		"- **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a transport layer for the USB3 Vision protocol.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SystemModule_genTLVersionMajor_get", _wrap_SystemModule_genTLVersionMajor_get, METH_O, "\n"
		"An integer property. Defines the major version number of the GenTL specification the GenTL Producer implementation complies with.\n"
		"This is a read only element. It defines the major version number of the GenTL specification the GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_genTLVersionMinor_get", _wrap_SystemModule_genTLVersionMinor_get, METH_O, "\n"
		"An integer property. Defines the minor version number of the GenTL specification the GenTL Producer implementation complies with.\n"
		"This is a read only element. It defines the minor version number of the GenTL specification the GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_genTLSFNCVersionMajor_get", _wrap_SystemModule_genTLSFNCVersionMajor_get, METH_O, "\n"
		"An integer property. Defines the major version number of the GenTL SFNC specification the GenTL Producer implementation complies with.\n"
		"This is a read only element. It defines the major version number of the GenTL SFNC specification the GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_genTLSFNCVersionMinor_get", _wrap_SystemModule_genTLSFNCVersionMinor_get, METH_O, "\n"
		"An integer property. Defines the minor version number of the GenTL SFNC specification the GenTL Producer implementation complies with.\n"
		"This is a read only element. It defines the minor version number of the GenTL SFNC specification the GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_genTLSFNCVersionSubMinor_get", _wrap_SystemModule_genTLSFNCVersionSubMinor_get, METH_O, "\n"
		"An integer property. Defines the sub minor version number of the GenTL SFNC specification the GenTL Producer implementation complies with.\n"
		"This is a read only element. It defines the sub minor version number of the GenTL SFNC specification the GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_genCPVersionMajor_get", _wrap_SystemModule_genCPVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the GenCP specification this GenTL Producer implementation complies with.\n"
		"This is a read only element. It indicates the major version number of the GenCP specification this GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_genCPVersionMinor_get", _wrap_SystemModule_genCPVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the GenCP specification this GenTL Producer implementation complies with.\n"
		"This is a read only element. It indicates the minor version number of the GenCP specification this GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_gevVersionMajor_get", _wrap_SystemModule_gevVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the GigE Vision specification this GenTL Producer implementation complies with.\n"
		"This is a read only element. It indicates the major version number of the GigE Vision specification this GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_gevVersionMinor_get", _wrap_SystemModule_gevVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the GigE Vision specification this GenTL Producer implementation complies with.\n"
		"This is a read only element. It indicates the minor version number of the GigE Vision specification this GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_u3vVersionMajor_get", _wrap_SystemModule_u3vVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the USB3 Vision specification this GenTL Producer implementation complies with.\n"
		"This is a read only element. It indicates the major version number of the USB3 Vision specification this GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_u3vVersionMinor_get", _wrap_SystemModule_u3vVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the USB3 Vision specification this GenTL Producer implementation complies with.\n"
		"This is a read only element. It indicates the minor version number of the USB3 Vision specification this GenTL Producer implementation complies with.\n"
		""},
	 { "SystemModule_mvGevChannelDummyPacketSendEnable_get", _wrap_SystemModule_mvGevChannelDummyPacketSendEnable_get, METH_O, "\n"
		"A boolean property. Enables or disables the periodical sending of dummy packets to a stream or message channel source port of a GigE Vision device.\n"
		"Enables or disables the periodical sending of dummy packets to a stream or message channel source port of a GigE Vision device. This might be useful to overcome firewall related problems when working with network devices.\n"
		""},
	 { "SystemModule_mvGevChannelDummyPacketSendInterval_get", _wrap_SystemModule_mvGevChannelDummyPacketSendInterval_get, METH_O, "\n"
		"An integer property. Defines the period(in ms) for sending dummy packets to a stream or message channel source port of a GigE Vision device.\n"
		"Defines the period(in ms) for sending dummy packets to a stream or message channel source port of a GigE Vision device. This might be useful to overcome firewall related problems when working with network devices.\n"
		""},
	 { "SystemModule_mvInterfaceTechnologyToIgnoreSelector_get", _wrap_SystemModule_mvInterfaceTechnologyToIgnoreSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects the interface technology type that should be ignored when updating the device list.\n"
		"Selects the interface technology type that should be ignored when updating the device list.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Mixed** (Display string: 'Mixed')\n"
		"- **Custom** (Display string: 'Custom')\n"
		"- **GEV** (Display string: 'GigE Vision')\n"
		"- **CameraLink** (Display string: 'CameraLink')\n"
		"- **CoaXPress** (Display string: 'CoaXPress')\n"
		"- **CameraLinkHS** (Display string: 'CameraLink HS')\n"
		"- **U3V** (Display string: 'USB3 Vision')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SystemModule_mvInterfaceTechnologyToIgnoreEnable_get", _wrap_SystemModule_mvInterfaceTechnologyToIgnoreEnable_get, METH_O, "\n"
		"A boolean property. When enabled, the selected interface technology type is ignored when updating the device list.\n"
		"When enabled, the selected interface technology type is ignored when updating the device list.\n"
		""},
	 { "SystemModule_interfaceUpdateList_get", _wrap_SystemModule_interfaceUpdateList_get, METH_O, "\n"
		"A method object. Updates the internal interface list.\n"
		"This command updates the internal interface list of this transport layer.\n"
		""},
	 { "SystemModule_interfaceUpdateTimeout_get", _wrap_SystemModule_interfaceUpdateTimeout_get, METH_O, "\n"
		"An integer property. Specifies timeout for the InterfaceUpdateList Command.\n"
		"Specifies timeout for the InterfaceUpdateList Command.\n"
		""},
	 { "SystemModule_interfaceSelector_get", _wrap_SystemModule_interfaceSelector_get, METH_O, "\n"
		"An integer property. Selector for the different GenTL Producer interfaces.\n"
		"Selector for the different GenTL Producer interfaces. Selector for the different GenTL Producer interfaces. This interface list only changes on execution of InterfaceUpdateList. The selector is 0-based in order to match the index of the C interface.\n"
		""},
	 { "SystemModule_interfaceID_get", _wrap_SystemModule_interfaceID_get, METH_O, "\n"
		"A string property. GenTL producer wide unique identifier of the selected interface.\n"
		"This is a read only element. It is a string that indicates a GenTL producer wide unique identifier of the selected interface.\n"
		""},
	 { "SystemModule_interfaceDisplayName_get", _wrap_SystemModule_interfaceDisplayName_get, METH_O, "\n"
		"A string property. A user-friendly name of the Interface.\n"
		"This is a read only element. It is a string that indicates a  user-friendly name of the Interface.\n"
		""},
	 { "SystemModule_interfaceType_get", _wrap_SystemModule_interfaceType_get, METH_O, "\n"
		"An enumerated integer property. Identifies the interfaces technology of the GenTL Producer implementation.\n"
		"This is a read only feature. This enumeration provides a value that indicates interfaces technology of the GenTL Producer implementation.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is an interface for a mixed protocol.\n"
		"- **Custom** (Display string: 'Custom'): This enumeration value indicates that this is an interface for a custom protocol.\n"
		"- **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is an interface for the GigE Vision protocol.\n"
		"- **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is an interface for the CameraLink protocol.\n"
		"- **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is an interface for the CoaXPress protocol.\n"
		"- **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is an interface for the CameraLink HS protocol.\n"
		"- **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is an interface for the USB3 Vision protocol.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SystemModule_gevInterfaceMACAddress_get", _wrap_SystemModule_gevInterfaceMACAddress_get, METH_O, "\n"
		"An integer property. Indicates the 48-bit MAC address of the selected interface.\n"
		"This is a read only element. It indicates the 48-bit MAC address of the selected interface.\n"
		""},
	 { "SystemModule_gevInterfaceDefaultIPAddress_get", _wrap_SystemModule_gevInterfaceDefaultIPAddress_get, METH_O, "\n"
		"An integer property. Indicates the IP address of the first subnet of the selected interface.\n"
		"This is a read only element. It indicates the IP address of the first subnet of the selected interface.\n"
		""},
	 { "SystemModule_gevInterfaceDefaultSubnetMask_get", _wrap_SystemModule_gevInterfaceDefaultSubnetMask_get, METH_O, "\n"
		"An integer property. Indicates the subnet mask of the first subnet of the selected interface.\n"
		"This is a read only element. It indicates the subnet mask of the first subnet of the selected interface.\n"
		""},
	 { "SystemModule_gevInterfaceDefaultGateway_get", _wrap_SystemModule_gevInterfaceDefaultGateway_get, METH_O, "\n"
		"An integer property. Indicates the default gateway of the first subnet of the selected interface.\n"
		"This is a read only element. It indicates the default gateway of the first subnet of the selected interface.\n"
		""},
	 { "SystemModule_mvGevInterfaceMTU_get", _wrap_SystemModule_mvGevInterfaceMTU_get, METH_O, "\n"
		"An integer property. Indicates the MTU of the selected interface.\n"
		"This is a read only element. It indicates the MTU(Maximum Transmission Unit) of the selected interface.\n"
		""},
	 { "SystemModule_mvGevInterfaceLinkSpeed_get", _wrap_SystemModule_mvGevInterfaceLinkSpeed_get, METH_O, "\n"
		"An integer property. Indicates the link speed of this interface.\n"
		"This is a read only element. It indicates the link speed(in Mbits per second) of this interface.\n"
		""},
	 { "SystemModule_mvDeviceUpdateListBehaviour_get", _wrap_SystemModule_mvDeviceUpdateListBehaviour_get, METH_O, "\n"
		"An enumerated integer property. Defines the behavior of the interface when the device list is being updated.\n"
		"Defines the behavior of the interface when the device list is being updated.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **NotConfigured** (Display string: 'Not Configured'): Interface will enumerate devices or not according to the general enumeration behavior of this interface type(according to mvInterfaceTechnologyToIgnoreEnable setting).\n"
		"- **ForceIgnore** (Display string: 'Force Ignore'): Interface will not enumerate devices, regardless of the the general enumeration behavior of this interface type(overrides mvInterfaceTechnologyToIgnoreEnable setting).\n"
		"- **ForceEnumerate** (Display string: 'Force Enumerate'): Interface will forcefully enumerate devices, regardless of the the general enumeration behavior of this interface type(overrides mvInterfaceTechnologyToIgnoreEnable setting).\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SystemModule_eventSelector_get", _wrap_SystemModule_eventSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Event to signal to the host application.\n"
		"Selects which Event to signal to the host application.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.\n"
		"- **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.\n"
		"- **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.\n"
		"- **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.\n"
		"- **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.\n"
		"- **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.\n"
		"- **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.\n"
		"- **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).\n"
		"- **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.\n"
		"- **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.\n"
		"- **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.\n"
		"- **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.\n"
		"- **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.\n"
		"- **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.\n"
		"- **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.\n"
		"- **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.\n"
		"- **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.\n"
		"- **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.\n"
		"- **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.\n"
		"- **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.\n"
		"- **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.\n"
		"- **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.\n"
		"- **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.\n"
		"- **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.\n"
		"- **DeviceTemperatureStateCritical** (Display string: 'Device Temperature State Critical')\n"
		"- **DeviceTemperatureStateNormal** (Display string: 'Device Temperature State Normal')\n"
		"- **DeviceTemperatureStateOverTemperature** (Display string: 'Device Temperature State Over Temperature')\n"
		"- **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.\n"
		"- **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.\n"
		"- **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.\n"
		"- **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.\n"
		"- **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.\n"
		"- **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.\n"
		"- **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.\n"
		"- **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.\n"
		"- **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.\n"
		"- **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.\n"
		"- **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.\n"
		"- **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.\n"
		"- **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.\n"
		"- **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.\n"
		"- **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.\n"
		"- **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.\n"
		"- **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.\n"
		"- **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.\n"
		"- **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.\n"
		"- **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.\n"
		"- **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.\n"
		"- **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.\n"
		"- **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.\n"
		"- **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.\n"
		"- **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.\n"
		"- **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.\n"
		"- **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.\n"
		"- **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.\n"
		"- **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.\n"
		"- **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.\n"
		"- **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.\n"
		"- **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.\n"
		"- **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.\n"
		"- **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.\n"
		"- **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.\n"
		"- **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.\n"
		"- **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.\n"
		"- **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.\n"
		"- **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.\n"
		"- **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.\n"
		"- **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.\n"
		"- **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.\n"
		"- **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.\n"
		"- **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.\n"
		"- **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.\n"
		"- **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.\n"
		"- **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.\n"
		"- **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.\n"
		"- **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.\n"
		"- **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.\n"
		"- **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.\n"
		"- **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.\n"
		"- **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.\n"
		"- **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.\n"
		"- **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.\n"
		"- **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.\n"
		"- **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.\n"
		"- **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.\n"
		"- **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.\n"
		"- **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.\n"
		"- **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.\n"
		"- **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.\n"
		"- **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.\n"
		"- **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.\n"
		"- **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.\n"
		"- **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.\n"
		"- **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.\n"
		"- **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.\n"
		"- **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.\n"
		"- **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.\n"
		"- **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.\n"
		"- **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.\n"
		"- **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.\n"
		"- **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.\n"
		"- **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.\n"
		"- **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.\n"
		"- **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.\n"
		"- **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.\n"
		"- **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.\n"
		"- **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.\n"
		"- **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.\n"
		"- **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.\n"
		"- **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.\n"
		"- **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.\n"
		"- **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.\n"
		"- **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.\n"
		"- **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.\n"
		"- **Link0Trigger** (Display string: 'Link 0 Trigger')\n"
		"- **Link1Trigger** (Display string: 'Link 1 Trigger')\n"
		"- **Link2Trigger** (Display string: 'Link 2 Trigger')\n"
		"- **Link3Trigger** (Display string: 'Link 3 Trigger')\n"
		"- **Link4Trigger** (Display string: 'Link 4 Trigger')\n"
		"- **Link5Trigger** (Display string: 'Link 5 Trigger')\n"
		"- **Link6Trigger** (Display string: 'Link 6 Trigger')\n"
		"- **Link7Trigger** (Display string: 'Link 7 Trigger')\n"
		"- **Link8Trigger** (Display string: 'Link 8 Trigger')\n"
		"- **Link9Trigger** (Display string: 'Link 9 Trigger')\n"
		"- **Link10Trigger** (Display string: 'Link 10 Trigger')\n"
		"- **Link11Trigger** (Display string: 'Link 11 Trigger')\n"
		"- **Link12Trigger** (Display string: 'Link 12 Trigger')\n"
		"- **Link13Trigger** (Display string: 'Link 13 Trigger')\n"
		"- **Link14Trigger** (Display string: 'Link 14 Trigger')\n"
		"- **Link15Trigger** (Display string: 'Link 15 Trigger')\n"
		"- **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.\n"
		"- **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).\n"
		"- **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.\n"
		"- **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.\n"
		"- **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.\n"
		"- **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.\n"
		"- **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.\n"
		"- **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.\n"
		"- **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.\n"
		"- **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.\n"
		"- **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.\n"
		"- **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.\n"
		"- **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.\n"
		"- **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.\n"
		"- **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.\n"
		"- **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.\n"
		"- **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.\n"
		"- **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.\n"
		"- **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.\n"
		"- **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.\n"
		"- **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.\n"
		"- **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.\n"
		"- **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.\n"
		"- **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.\n"
		"- **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.\n"
		"- **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.\n"
		"- **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SystemModule_eventNotification_get", _wrap_SystemModule_eventNotification_get, METH_O, "\n"
		"An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The selected Event notification is disabled.\n"
		"- **On** (Display string: 'On'): The selected Event notification is enabled.\n"
		"- **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.\n"
		"- **GigEVisionEvent** (Display string: 'Gig E Vision Event')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "SystemModule_getSystemModuleCount", _wrap_SystemModule_getSystemModuleCount, METH_NOARGS, "\n"
		"Returns the number of GenTL producers detected in the current system.\n"
		"This is also the number of system modules detected thus this value - 1 defines the maximum value that can\n"
		"be passed as the *index* parameter into a **mvIMPACT::acquire::SystemModule** constructor.\n"
		"Since: 2.32.0\n"
		""},
	 { "SystemModule_getInterfaceModuleCount", _wrap_SystemModule_getInterfaceModuleCount, METH_O, "\n"
		" Returns the number of interfaces associated with this GenTL producer.\n"
		"This should return the same value as when calling **mvIMPACT::acquire::GenICam::SystemModule::interfaceSelector::getMaxValue**\n"
		"however there are producers out there that do not implement the ``interfaceSelector`` property correctly.\n"
		"\n"
		" Since: 2.34.0\n"
		""},
	 { "delete_SystemModule", _wrap_delete_SystemModule, METH_O, NULL},
	 { "SystemModule_swigregister", SystemModule_swigregister, METH_O, NULL},
	 { "SystemModule_swiginit", SystemModule_swiginit, METH_VARARGS, NULL},
	 { "new_InterfaceModule", _wrap_new_InterfaceModule, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::InterfaceModule** object.\n"
		" Since: 2.32.0\n"
		"\n"
		":type parent: :py:class:`SystemModule`\n"
		":param parent: [in] The **mvIMPACT::acquire::GenICam::SystemModule** instance providing access to the interface module to be created.\n"
		":type index: int\n"
		":param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.\n"
		""},
	 { "InterfaceModule_interfaceID_get", _wrap_InterfaceModule_interfaceID_get, METH_O, "\n"
		"A string property. GenTL producer wide unique identifier of the selected interface.\n"
		"This is a read only element. It is a string that indicates a GenTL producer wide unique identifier of the selected interface.\n"
		""},
	 { "InterfaceModule_interfaceDisplayName_get", _wrap_InterfaceModule_interfaceDisplayName_get, METH_O, "\n"
		"A string property. A user-friendly name of the Interface.\n"
		"This is a read only element. It is a string that indicates a  user-friendly name of the Interface.\n"
		""},
	 { "InterfaceModule_interfaceType_get", _wrap_InterfaceModule_interfaceType_get, METH_O, "\n"
		"An enumerated integer property. Identifies the interfaces technology of the GenTL Producer implementation.\n"
		"This is a read only feature. This enumeration provides a value that indicates interfaces technology of the GenTL Producer implementation.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is an interface for a mixed protocol.\n"
		"- **Custom** (Display string: 'Custom'): This enumeration value indicates that this is an interface for a custom protocol.\n"
		"- **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is an interface for the GigE Vision protocol.\n"
		"- **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is an interface for the CameraLink protocol.\n"
		"- **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is an interface for the CoaXPress protocol.\n"
		"- **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is an interface for the CameraLink HS protocol.\n"
		"- **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is an interface for the USB3 Vision protocol.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "InterfaceModule_interfaceTLVersionMajor_get", _wrap_InterfaceModule_interfaceTLVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the transport layer specification the GenTL Producer complies with.\n"
		"This is a read only element. It indicates the major version number of the transport layer specification the GenTL Producer complies with.\n"
		""},
	 { "InterfaceModule_interfaceTLVersionMinor_get", _wrap_InterfaceModule_interfaceTLVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the transport layer specification the GenTL Producer complies with.\n"
		"This is a read only element. It indicates the minor version number of the transport layer specification the GenTL Producer complies with.\n"
		""},
	 { "InterfaceModule_mvInterfaceLicenseFile_get", _wrap_InterfaceModule_mvInterfaceLicenseFile_get, METH_O, "\n"
		"A string property. Indicates the path of the license file.\n"
		"This string register indicates the path of the file that will be used for extracting licenses for devices on this interface.\n"
		""},
	 { "InterfaceModule_gevInterfaceGatewaySelector_get", _wrap_InterfaceModule_gevInterfaceGatewaySelector_get, METH_O, "\n"
		"An integer property. Selector for the different gateway entries for this interface.\n"
		"Selector for the different gateway entries for this interface. The selector is 0-based in order to match the index of the C interface.\n"
		""},
	 { "InterfaceModule_gevInterfaceGateway_get", _wrap_InterfaceModule_gevInterfaceGateway_get, METH_O, "\n"
		"An integer property. Indicates the IP address of the selected gateway entry of this interface.\n"
		"This is a read only element. It indicates the IP address of the selected gateway entry of this interface.\n"
		""},
	 { "InterfaceModule_gevInterfaceMACAddress_get", _wrap_InterfaceModule_gevInterfaceMACAddress_get, METH_O, "\n"
		"An integer property. Indicates the 48-bit MAC address of the selected interface.\n"
		"This is a read only element. It indicates the 48-bit MAC address of the selected interface.\n"
		""},
	 { "InterfaceModule_gevInterfaceSubnetSelector_get", _wrap_InterfaceModule_gevInterfaceSubnetSelector_get, METH_O, "\n"
		"An integer property. Selector for the different subnet entries for this interface.\n"
		"Selector for the different subnet entries for this interface. The selector is 0-based in order to match the index of the C interface.\n"
		""},
	 { "InterfaceModule_gevInterfaceSubnetIPAddress_get", _wrap_InterfaceModule_gevInterfaceSubnetIPAddress_get, METH_O, "\n"
		"An integer property. Indicates the IP address of the selected subnet entry of this interface.\n"
		"This is a read only element. It indicates the IP address of the selected subnet entry of this interface.\n"
		""},
	 { "InterfaceModule_gevInterfaceSubnetMask_get", _wrap_InterfaceModule_gevInterfaceSubnetMask_get, METH_O, "\n"
		"An integer property. Indicates the subnet mask of the selected subnet entry of this interface.\n"
		"This is a read only element. It indicates the subnet mask of the selected subnet entry of this interface.\n"
		""},
	 { "InterfaceModule_mvGevInterfaceMTU_get", _wrap_InterfaceModule_mvGevInterfaceMTU_get, METH_O, "\n"
		"An integer property. Indicates the MTU of this interface.\n"
		"This is a read only element. It indicates the MTU(Maximum Transmission Unit) of this interface.\n"
		""},
	 { "InterfaceModule_mvGevInterfaceLinkSpeed_get", _wrap_InterfaceModule_mvGevInterfaceLinkSpeed_get, METH_O, "\n"
		"An integer property. Indicates the link speed of this interface.\n"
		"This is a read only element. It indicates the link speed(in Mbits per second) of this interface.\n"
		""},
	 { "InterfaceModule_mvGevAdvancedDeviceDiscoveryEnable_get", _wrap_InterfaceModule_mvGevAdvancedDeviceDiscoveryEnable_get, METH_O, "\n"
		"A boolean property. Enables or disables the advanced device discovery.\n"
		"Enables or disables the advanced device discovery. When enabled also devices, which currently use an incorrect IP configuration for the network they are connected to might be detectable. However depending on the operating system this may result in devices showing up on interfaces to which they are not physically connected.\n"
		""},
	 { "InterfaceModule_deviceUpdateList_get", _wrap_InterfaceModule_deviceUpdateList_get, METH_O, "\n"
		"A method object. Updates the internal device list of this interface.\n"
		"This command updates the internal device list of this interface.\n"
		""},
	 { "InterfaceModule_mvUnicastDeviceDiscoveryCommandCount_get", _wrap_InterfaceModule_mvUnicastDeviceDiscoveryCommandCount_get, METH_O, "\n"
		"An integer property. Specifies the number of discovery commands which will be sent to destinations defined by 'mvUnicastDeviceDiscoveryCommandSelector' and 'mvUnicastDeviceDiscoveryDestinationIPAddress'.\n"
		"Specifies the number of discovery commands which will be sent to destinations defined by 'mvUnicastDeviceDiscoveryCommandSelector' and 'mvUnicastDeviceDiscoveryDestinationIPAddress'. No unicast device discovery will be performed once set to '0'. The mvUnicastDeviceDiscoveryCommandCount specifies the maximum value of the mvUnicastDeviceDiscoveryCommandSelector property.\n"
		""},
	 { "InterfaceModule_mvUnicastDeviceDiscoveryCommandSelector_get", _wrap_InterfaceModule_mvUnicastDeviceDiscoveryCommandSelector_get, METH_O, "\n"
		"An integer property. Selects unicast discovery command to configure.\n"
		"Selects unicast discovery command to configure.\n"
		""},
	 { "InterfaceModule_mvUnicastDeviceDiscoveryDestinationIPAddress_get", _wrap_InterfaceModule_mvUnicastDeviceDiscoveryDestinationIPAddress_get, METH_O, "\n"
		"An integer property. Controls the destination IP address of the selected unicast device discovery command.\n"
		"Controls the destination IP address of the selected unicast device discovery command.\n"
		""},
	 { "InterfaceModule_deviceUpdateTimeout_get", _wrap_InterfaceModule_deviceUpdateTimeout_get, METH_O, "\n"
		"An integer property. Specifies timeout for the DeviceUpdateList Command.\n"
		"Specifies timeout for the DeviceUpdateList Command.\n"
		""},
	 { "InterfaceModule_deviceSelector_get", _wrap_InterfaceModule_deviceSelector_get, METH_O, "\n"
		"An integer property. Selector for the different devices on this interface.\n"
		"Selector for the different devices on this interface. The limits of this feature might change upon execution of DeviceUpdateList.\n"
		""},
	 { "InterfaceModule_deviceID_get", _wrap_InterfaceModule_deviceID_get, METH_O, "\n"
		"A string property. This feature is deprecated (See DeviceSerialNumber).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceSerialNumber). It was representing the Device unique identifier (serial number).\n"
		""},
	 { "InterfaceModule_deviceVendorName_get", _wrap_InterfaceModule_deviceVendorName_get, METH_O, "\n"
		"A string property. Name of the manufacturer of the device.\n"
		"Name of the manufacturer of the device.\n"
		""},
	 { "InterfaceModule_deviceModelName_get", _wrap_InterfaceModule_deviceModelName_get, METH_O, "\n"
		"A string property. Model of the device.\n"
		"Model of the device.\n"
		""},
	 { "InterfaceModule_deviceType_get", _wrap_InterfaceModule_deviceType_get, METH_O, "\n"
		"An enumerated integer property. Returns the device type.\n"
		"Returns the device type.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Transmitter** (Display string: 'Transmitter'): Data stream transmitter device.\n"
		"- **Receiver** (Display string: 'Receiver'): Data stream receiver device.\n"
		"- **Transceiver** (Display string: 'Transceiver'): Data stream receiver and transmitter device.\n"
		"- **Peripheral** (Display string: 'Peripheral'): Controllable device (with no data stream handling).\n"
		"- **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a device for a mixed protocol.\n"
		"- **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a device for a custom protocol.\n"
		"- **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a device for the GigE Vision protocol.\n"
		"- **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a device for the CameraLink protocol.\n"
		"- **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a device for the CoaXPress protocol.\n"
		"- **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a device for the CameraLink HS protocol.\n"
		"- **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a device for the USB3 Vision protocol.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "InterfaceModule_deviceLinkSpeed_get", _wrap_InterfaceModule_deviceLinkSpeed_get, METH_O, "\n"
		"An integer property. Indicates the speed of transmission negotiated on the specified Link.\n"
		"Indicates the speed of transmission negotiated on the specified Link.\n"
		""},
	 { "InterfaceModule_deviceAccessStatus_get", _wrap_InterfaceModule_deviceAccessStatus_get, METH_O, "\n"
		"An enumerated integer property. Indicates the current access status for the device.\n"
		"This is a read only feature. This enumeration gives the device's access status at the moment of the last execution of the DeviceUpdateList command. This value only changes on execution of the DeviceUpdateList command.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Unknown** (Display string: 'Unknown'): This enumeration value indicates that the device accessibility is not known.\n"
		"- **ReadWrite** (Display string: 'Read/Write'): This enumeration value indicates that full access to the device is available.\n"
		"- **ReadOnly** (Display string: 'Read Only'): This enumeration value indicates that read access to the device is available.\n"
		"- **NoAccess** (Display string: 'No Access'): This enumeration value indicates that no access to the device is available.\n"
		"- **Busy** (Display string: 'Busy'): This enumeration value indicates that the device is already opened by another entity.\n"
		"- **OpenReadWrite** (Display string: 'Open Read Write'): This enumeration value indicates that the device is open in Read/Write mode by this GenTL host.\n"
		"- **OpenReadOnly** (Display string: 'Open Read Only'): This enumeration value indicates that the device is open in Read only mode by this GenTL host.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "InterfaceModule_deviceSerialNumber_get", _wrap_InterfaceModule_deviceSerialNumber_get, METH_O, "\n"
		"A string property. Device's serial number.\n"
		"Device's serial number. This string is a unique identifier of the device.\n"
		""},
	 { "InterfaceModule_mvU3VDeviceGUID_get", _wrap_InterfaceModule_mvU3VDeviceGUID_get, METH_O, "\n"
		"A string property. Indicates the USB3 Vision GUID of the device.\n"
		"This is a read only element. It indicates the USB3 Vision GUID of the device.\n"
		""},
	 { "InterfaceModule_deviceUserID_get", _wrap_InterfaceModule_deviceUserID_get, METH_O, "\n"
		"A string property. User-programmable device identifier.\n"
		"User-programmable device identifier.\n"
		""},
	 { "InterfaceModule_deviceTLVersionMajor_get", _wrap_InterfaceModule_deviceTLVersionMajor_get, METH_O, "\n"
		"An integer property. Major version of the Transport Layer of the device.\n"
		"Major version of the Transport Layer of the device.\n"
		""},
	 { "InterfaceModule_deviceTLVersionMinor_get", _wrap_InterfaceModule_deviceTLVersionMinor_get, METH_O, "\n"
		"An integer property. Minor version of the Transport Layer of the device.\n"
		"Minor version of the Transport Layer of the device.\n"
		""},
	 { "InterfaceModule_gevDeviceIPAddress_get", _wrap_InterfaceModule_gevDeviceIPAddress_get, METH_O, "\n"
		"An integer property. Indicates the current IP address of the GVCP interface of the selected remote device.\n"
		"This is a read only element. It indicates the current IP address of the GVCP interface of the selected remote device.\n"
		""},
	 { "InterfaceModule_gevDeviceSubnetMask_get", _wrap_InterfaceModule_gevDeviceSubnetMask_get, METH_O, "\n"
		"An integer property. Indicates the current subnet mask of the GVCP interface of the selected remote device.\n"
		"This is a read only element. It indicates the current subnet mask of the GVCP interface of the selected remote device.\n"
		""},
	 { "InterfaceModule_gevDeviceGateway_get", _wrap_InterfaceModule_gevDeviceGateway_get, METH_O, "\n"
		"An integer property. Indicates the current gateway of the GVCP interface of the selected remote device.\n"
		"This is a read only element. It indicates the current gateway of the GVCP interface of the selected remote device.\n"
		""},
	 { "InterfaceModule_gevDeviceIPConfigurationStatus_get", _wrap_InterfaceModule_gevDeviceIPConfigurationStatus_get, METH_O, "\n"
		"An enumerated integer property. Identifies the IP configuration of the GVCP interface of the selected remote device.\n"
		"This is a read only feature. This enumeration provides a value that indicates the Device IP configuration of the GVCP interface of the selected remote device. This value only changes on execution of the DeviceUpdateList command.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **DHCP** (Display string: 'DHCP')\n"
		"- **PersistentIP** (Display string: 'Persistent IP')\n"
		"- **LinkLocal** (Display string: 'Link Local')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "InterfaceModule_gevDeviceMACAddress_get", _wrap_InterfaceModule_gevDeviceMACAddress_get, METH_O, "\n"
		"An integer property. Indicates the 48-bit MAC address of the GVCP interface of the selected remote device.\n"
		"This is a read only element. It indicates the 48-bit MAC address of the GVCP interface of the selected remote device.\n"
		""},
	 { "InterfaceModule_gevCurrentControlMode_get", _wrap_InterfaceModule_gevCurrentControlMode_get, METH_O, "\n"
		"An enumerated integer property. The current control mode of the device.\n"
		"This enumeration provides a value that indicates the current control mode of the device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Open** (Display string: 'Open'): This enumeration value indicates that the device is open for control or exclusive access.\n"
		"- **ControlAccess** (Display string: 'Control Access'): This enumeration value indicates that the device is controlled by another host, but switchover or read-only access is possible.\n"
		"- **ExclusiveAccess** (Display string: 'Exclusive Access'): This enumeration value indicates that the device is under exclusive access by a host and cannot be accessed by another.\n"
		"- **NoAccess** (Display string: 'No Access'): This enumeration value indicates that the device cannot be accessed, for instance it may be a GigE Vision device on a subnet different from the interface.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "InterfaceModule_mvDeviceCommandChannelTransmissionTimeout_get", _wrap_InterfaceModule_mvDeviceCommandChannelTransmissionTimeout_get, METH_O, "\n"
		"An integer property. Defines the maximum time in milli-seconds the host driver will wait for an ACK from the device to a previously sent command(deprecated).\n"
		"Deprecated: \n"
		"Defines the maximum time in milli-seconds the host driver will wait for an ACK from the device to a previously sent command. This feature has been declared deprecated. Use 'LinkCommandTimeout' of the DeviceModule instead.\n"
		""},
	 { "InterfaceModule_mvDeviceCommandChannelRetryCount_get", _wrap_InterfaceModule_mvDeviceCommandChannelRetryCount_get, METH_O, "\n"
		"An integer property. Indicates the number of retransmissions allowed when command channel message timed out (no ACK was received from the device)(deprecated).\n"
		"Deprecated: \n"
		"Indicates the number of retransmissions allowed when command channel message timed out (no ACK was received from the device). This feature has been declared deprecated. Use 'LinkCommandRetryCount' of the DeviceModule instead.\n"
		""},
	 { "InterfaceModule_gevVersionMajor_get", _wrap_InterfaceModule_gevVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the GigE Vision specification this device complies with.\n"
		"This is a read only element. It indicates the major version number of the GigE Vision specification this device complies with.\n"
		""},
	 { "InterfaceModule_gevVersionMinor_get", _wrap_InterfaceModule_gevVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the GigE Vision specification this device complies with.\n"
		"This is a read only element. It indicates the minor version number of the GigE Vision specification this device complies with.\n"
		""},
	 { "InterfaceModule_genCPVersionMajor_get", _wrap_InterfaceModule_genCPVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the GenCP specification this device complies with.\n"
		"This is a read only element. It indicates the major version number of the GenCP specification this device complies with.\n"
		""},
	 { "InterfaceModule_genCPVersionMinor_get", _wrap_InterfaceModule_genCPVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the GenCP specification this device complies with.\n"
		"This is a read only element. It indicates the minor version number of the GenCP specification this device complies with.\n"
		""},
	 { "InterfaceModule_u3vVersionMajor_get", _wrap_InterfaceModule_u3vVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the USB3 Vision specification this device complies with.\n"
		"This is a read only element. It indicates the major version number of the USB3 Vision specification this device complies with.\n"
		""},
	 { "InterfaceModule_u3vVersionMinor_get", _wrap_InterfaceModule_u3vVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the USB3 Vision specification this device complies with.\n"
		"This is a read only element. It indicates the minor version number of the USB3 Vision specification this device complies with.\n"
		""},
	 { "InterfaceModule_mvDevicePrimaryApplicationSwitchoverSupported_get", _wrap_InterfaceModule_mvDevicePrimaryApplicationSwitchoverSupported_get, METH_O, "\n"
		"A boolean property. Reports the availability of the primary application switchover feature.\n"
		"Reports the availability of the primary application switchover feature.\n"
		""},
	 { "InterfaceModule_mvDevicePrimaryApplicationSwitchoverEnable_get", _wrap_InterfaceModule_mvDevicePrimaryApplicationSwitchoverEnable_get, METH_O, "\n"
		"A boolean property. Enables or disables primary application switchover.\n"
		"Enables or disables primary application switchover.\n"
		""},
	 { "InterfaceModule_gevApplicationSwitchoverKey_get", _wrap_InterfaceModule_gevApplicationSwitchoverKey_get, METH_O, "\n"
		"An integer property. Controls the key to use to authenticate primary application switchover requests.\n"
		"Controls the key to use to authenticate primary application switchover requests. If the device to take over has 'mvDevicePrimaryApplicationSwitchoverEnable' set to true and this key matches the devices internal key control access will be granted.\n"
		""},
	 { "InterfaceModule_mvDeviceNetworkInterfaceCount_get", _wrap_InterfaceModule_mvDeviceNetworkInterfaceCount_get, METH_O, "\n"
		"An integer property. The number of physical network interfaces supported by this device.\n"
		"This is an integer feature. It contains the number of physical network interfaces supported by this device.\n"
		""},
	 { "InterfaceModule_gevDeviceForceIP_get", _wrap_InterfaceModule_gevDeviceForceIP_get, METH_O, "\n"
		"A method object. Apply the force IP settings (GevDeviceForceIPAddress, GevDeviceForceSubnetMask and GevDeviceForceGateway) in the Device using ForceIP command.\n"
		"Apply the force IP settings (GevDeviceForceIPAddress, GevDeviceForceSubnetMask and GevDeviceForceGateway) in the Device using ForceIP command.\n"
		""},
	 { "InterfaceModule_gevDeviceForceIPAddress_get", _wrap_InterfaceModule_gevDeviceForceIPAddress_get, METH_O, "\n"
		"An integer property. Static IP address to set for the GVCP interface of the selected remote device.\n"
		"Static IP address to set for the GVCP interface of the selected remote device.\n"
		""},
	 { "InterfaceModule_gevDeviceForceSubnetMask_get", _wrap_InterfaceModule_gevDeviceForceSubnetMask_get, METH_O, "\n"
		"An integer property. Static subnet mask to set for the GVCP interface of the selected remote device.\n"
		"Static subnet mask to set for the GVCP interface of the selected remote device.\n"
		""},
	 { "InterfaceModule_gevDeviceForceGateway_get", _wrap_InterfaceModule_gevDeviceForceGateway_get, METH_O, "\n"
		"An integer property. Static gateway IP address to set for the GVCP interface of the selected remote device.\n"
		"Static gateway IP address to set for the GVCP interface of the selected remote device.\n"
		""},
	 { "InterfaceModule_mvDeviceUpdateFirmware_get", _wrap_InterfaceModule_mvDeviceUpdateFirmware_get, METH_O, "\n"
		"A method object. Updates the device's firmware.\n"
		"Updates the device using the firmware images embedded into this producer library.\n"
		""},
	 { "InterfaceModule_mvDeviceLicenseValid_get", _wrap_InterfaceModule_mvDeviceLicenseValid_get, METH_O, "\n"
		"A boolean property. True if the current device has a valid license.\n"
		"True if the current device has a valid license. This is the case for all MATRIX VISION and Balluff devices and devices for which a license file has been provided.\n"
		""},
	 { "InterfaceModule_mvDeviceLicenseDetails_get", _wrap_InterfaceModule_mvDeviceLicenseDetails_get, METH_O, "\n"
		"A string property. Details about the granted license.\n"
		"This is a read only element. It indicates details whether or not this device can be operated without limitations using this driver stack.\n"
		""},
	 { "InterfaceModule_actionCommand_get", _wrap_InterfaceModule_actionCommand_get, METH_O, "\n"
		"A method object. Sends the action command\n"
		"It either sends an action command unicast packet to the IP address specified by the 'mvActionDestinationIPAddress' property, or broadcasts an action command broadcast packet on the broadcast domain specified by the 'mvActionDestinationIPAddress' property\n"
		""},
	 { "InterfaceModule_actionDeviceKey_get", _wrap_InterfaceModule_actionDeviceKey_get, METH_O, "\n"
		"An integer property. The device key for the action command\n"
		"The device key is one of the three main components that constitute an action command packet. It partly defines which device(s) will positively assert the action command packet.\n"
		""},
	 { "InterfaceModule_actionGroupKey_get", _wrap_InterfaceModule_actionGroupKey_get, METH_O, "\n"
		"An integer property. The group key for the action command\n"
		"The group key is one of the three main components that constitute an action command packet. It partly defines which device(s) will positively assert the action command packet.\n"
		""},
	 { "InterfaceModule_actionGroupMask_get", _wrap_InterfaceModule_actionGroupMask_get, METH_O, "\n"
		"An integer property. The group mask for the action command\n"
		"The group mask is one of the three main components that constitute an action command packet. It partly defines which device(s) will positively assert the action command packet.\n"
		""},
	 { "InterfaceModule_actionScheduledTimeEnable_get", _wrap_InterfaceModule_actionScheduledTimeEnable_get, METH_O, "\n"
		"A boolean property. Enables or disables action command scheduling\n"
		"Action commands can be scheduled to execute at a particular moment in time, defined by the 'mvActionScheduledTime' property. If this is disabled the action command takes place immediately after it is received and asserted by each device.\n"
		""},
	 { "InterfaceModule_actionScheduledTime_get", _wrap_InterfaceModule_actionScheduledTime_get, METH_O, "\n"
		"An integer property. Sets the time in which the action command will be executed\n"
		"Sets the time in which the action command will be executed\n"
		""},
	 { "InterfaceModule_gevActionDestinationIPAddress_get", _wrap_InterfaceModule_gevActionDestinationIPAddress_get, METH_O, "\n"
		"An integer property. The IP address of the action command recipient\n"
		"A valid IP address if the action command shall be unicast. A broadcast subnet if the action command shall be broadcast.\n"
		""},
	 { "InterfaceModule_mvActionAcknowledgeEnable_get", _wrap_InterfaceModule_mvActionAcknowledgeEnable_get, METH_O, "\n"
		"A boolean property. Enables or disables the ACK response for the action command\n"
		"Enables or disables the ACK response packet for an action command by setting the corresponding flag in the command. Typically, invokers of an action command don't wait for an acknowledge which is why this flag is usually not set in the command.\n"
		""},
	 { "InterfaceModule_mvActionAcknowledgesExpected_get", _wrap_InterfaceModule_mvActionAcknowledgesExpected_get, METH_O, "\n"
		"An integer property. Number of devices to send an acknowledge to the action command generated in the current setup\n"
		"An unsigned integer containing the number of devices that are expected to send an acknowledge to the action command generated in the current setup.\n"
		""},
	 { "InterfaceModule_mvActionAcknowledgeTimeout_get", _wrap_InterfaceModule_mvActionAcknowledgeTimeout_get, METH_O, "\n"
		"An integer property. Maximum wait time for the acknowledge o an action command(ms)\n"
		"Maximum wait time for the acknowledge to the action command generated in the current setup(ms).\n"
		""},
	 { "InterfaceModule_mvActionAcknowledgesReceived_get", _wrap_InterfaceModule_mvActionAcknowledgesReceived_get, METH_O, "\n"
		"An integer property. Number of devices that sent an acknowledge to the recent action command\n"
		"Number of devices that sent an acknowledge as a response to the recent action command generated in the current setup.\n"
		""},
	 { "InterfaceModule_mvActionAcknowledgesFailed_get", _wrap_InterfaceModule_mvActionAcknowledgesFailed_get, METH_O, "\n"
		"An integer property. Number of devices that sent an acknowledge with an error code to the recent action command\n"
		"Number of devices that sent an acknowledge with an error code as a response to the recent action command generated in the current setup.\n"
		""},
	 { "InterfaceModule_eventSelector_get", _wrap_InterfaceModule_eventSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Event to signal to the host application.\n"
		"Selects which Event to signal to the host application.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.\n"
		"- **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.\n"
		"- **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.\n"
		"- **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.\n"
		"- **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.\n"
		"- **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.\n"
		"- **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.\n"
		"- **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).\n"
		"- **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.\n"
		"- **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.\n"
		"- **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.\n"
		"- **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.\n"
		"- **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.\n"
		"- **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.\n"
		"- **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.\n"
		"- **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.\n"
		"- **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.\n"
		"- **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.\n"
		"- **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.\n"
		"- **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.\n"
		"- **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.\n"
		"- **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.\n"
		"- **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.\n"
		"- **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.\n"
		"- **DeviceTemperatureStateCritical** (Display string: 'Device Temperature State Critical')\n"
		"- **DeviceTemperatureStateNormal** (Display string: 'Device Temperature State Normal')\n"
		"- **DeviceTemperatureStateOverTemperature** (Display string: 'Device Temperature State Over Temperature')\n"
		"- **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.\n"
		"- **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.\n"
		"- **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.\n"
		"- **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.\n"
		"- **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.\n"
		"- **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.\n"
		"- **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.\n"
		"- **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.\n"
		"- **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.\n"
		"- **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.\n"
		"- **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.\n"
		"- **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.\n"
		"- **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.\n"
		"- **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.\n"
		"- **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.\n"
		"- **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.\n"
		"- **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.\n"
		"- **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.\n"
		"- **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.\n"
		"- **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.\n"
		"- **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.\n"
		"- **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.\n"
		"- **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.\n"
		"- **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.\n"
		"- **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.\n"
		"- **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.\n"
		"- **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.\n"
		"- **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.\n"
		"- **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.\n"
		"- **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.\n"
		"- **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.\n"
		"- **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.\n"
		"- **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.\n"
		"- **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.\n"
		"- **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.\n"
		"- **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.\n"
		"- **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.\n"
		"- **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.\n"
		"- **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.\n"
		"- **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.\n"
		"- **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.\n"
		"- **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.\n"
		"- **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.\n"
		"- **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.\n"
		"- **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.\n"
		"- **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.\n"
		"- **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.\n"
		"- **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.\n"
		"- **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.\n"
		"- **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.\n"
		"- **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.\n"
		"- **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.\n"
		"- **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.\n"
		"- **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.\n"
		"- **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.\n"
		"- **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.\n"
		"- **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.\n"
		"- **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.\n"
		"- **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.\n"
		"- **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.\n"
		"- **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.\n"
		"- **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.\n"
		"- **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.\n"
		"- **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.\n"
		"- **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.\n"
		"- **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.\n"
		"- **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.\n"
		"- **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.\n"
		"- **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.\n"
		"- **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.\n"
		"- **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.\n"
		"- **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.\n"
		"- **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.\n"
		"- **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.\n"
		"- **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.\n"
		"- **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.\n"
		"- **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.\n"
		"- **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.\n"
		"- **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.\n"
		"- **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.\n"
		"- **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.\n"
		"- **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.\n"
		"- **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.\n"
		"- **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.\n"
		"- **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.\n"
		"- **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.\n"
		"- **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.\n"
		"- **Link0Trigger** (Display string: 'Link 0 Trigger')\n"
		"- **Link1Trigger** (Display string: 'Link 1 Trigger')\n"
		"- **Link2Trigger** (Display string: 'Link 2 Trigger')\n"
		"- **Link3Trigger** (Display string: 'Link 3 Trigger')\n"
		"- **Link4Trigger** (Display string: 'Link 4 Trigger')\n"
		"- **Link5Trigger** (Display string: 'Link 5 Trigger')\n"
		"- **Link6Trigger** (Display string: 'Link 6 Trigger')\n"
		"- **Link7Trigger** (Display string: 'Link 7 Trigger')\n"
		"- **Link8Trigger** (Display string: 'Link 8 Trigger')\n"
		"- **Link9Trigger** (Display string: 'Link 9 Trigger')\n"
		"- **Link10Trigger** (Display string: 'Link 10 Trigger')\n"
		"- **Link11Trigger** (Display string: 'Link 11 Trigger')\n"
		"- **Link12Trigger** (Display string: 'Link 12 Trigger')\n"
		"- **Link13Trigger** (Display string: 'Link 13 Trigger')\n"
		"- **Link14Trigger** (Display string: 'Link 14 Trigger')\n"
		"- **Link15Trigger** (Display string: 'Link 15 Trigger')\n"
		"- **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.\n"
		"- **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).\n"
		"- **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.\n"
		"- **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.\n"
		"- **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.\n"
		"- **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.\n"
		"- **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.\n"
		"- **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.\n"
		"- **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.\n"
		"- **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.\n"
		"- **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.\n"
		"- **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.\n"
		"- **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.\n"
		"- **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.\n"
		"- **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.\n"
		"- **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.\n"
		"- **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.\n"
		"- **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.\n"
		"- **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.\n"
		"- **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.\n"
		"- **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.\n"
		"- **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.\n"
		"- **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.\n"
		"- **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.\n"
		"- **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.\n"
		"- **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.\n"
		"- **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "InterfaceModule_eventNotification_get", _wrap_InterfaceModule_eventNotification_get, METH_O, "\n"
		"An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The selected Event notification is disabled.\n"
		"- **On** (Display string: 'On'): The selected Event notification is enabled.\n"
		"- **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.\n"
		"- **GigEVisionEvent** (Display string: 'Gig E Vision Event')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_InterfaceModule", _wrap_delete_InterfaceModule, METH_O, NULL},
	 { "InterfaceModule_swigregister", InterfaceModule_swigregister, METH_O, NULL},
	 { "InterfaceModule_swiginit", InterfaceModule_swiginit, METH_VARARGS, NULL},
	 { "new_DeviceModule", _wrap_new_DeviceModule, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::DeviceModule** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "DeviceModule_deviceID_get", _wrap_DeviceModule_deviceID_get, METH_O, "\n"
		"A string property. This feature is deprecated (See DeviceSerialNumber).\n"
		"Deprecated: \n"
		"This feature is deprecated (See DeviceSerialNumber). It was representing the Device unique identifier (serial number).\n"
		""},
	 { "DeviceModule_deviceSerialNumber_get", _wrap_DeviceModule_deviceSerialNumber_get, METH_O, "\n"
		"A string property. Device's serial number.\n"
		"Device's serial number. This string is a unique identifier of the device.\n"
		""},
	 { "DeviceModule_deviceUserID_get", _wrap_DeviceModule_deviceUserID_get, METH_O, "\n"
		"A string property. User-programmable device identifier.\n"
		"User-programmable device identifier.\n"
		""},
	 { "DeviceModule_deviceVendorName_get", _wrap_DeviceModule_deviceVendorName_get, METH_O, "\n"
		"A string property. Name of the manufacturer of the device.\n"
		"Name of the manufacturer of the device.\n"
		""},
	 { "DeviceModule_deviceModelName_get", _wrap_DeviceModule_deviceModelName_get, METH_O, "\n"
		"A string property. Model of the device.\n"
		"Model of the device.\n"
		""},
	 { "DeviceModule_deviceFamilyName_get", _wrap_DeviceModule_deviceFamilyName_get, METH_O, "\n"
		"A string property. Identifier of the product family of the device.\n"
		"Identifier of the product family of the device.\n"
		""},
	 { "DeviceModule_deviceVersion_get", _wrap_DeviceModule_deviceVersion_get, METH_O, "\n"
		"A string property. Version of the device.\n"
		"Version of the device.\n"
		""},
	 { "DeviceModule_mvU3VDeviceGUID_get", _wrap_DeviceModule_mvU3VDeviceGUID_get, METH_O, "\n"
		"A string property. Indicates the USB3 Vision GUID of the device.\n"
		"This is a read only element. It indicates the USB3 Vision GUID of the device.\n"
		""},
	 { "DeviceModule_deviceManufacturerInfo_get", _wrap_DeviceModule_deviceManufacturerInfo_get, METH_O, "\n"
		"A string property. Manufacturer information about the device.\n"
		"Manufacturer information about the device.\n"
		""},
	 { "DeviceModule_deviceType_get", _wrap_DeviceModule_deviceType_get, METH_O, "\n"
		"An enumerated integer property. Returns the device type.\n"
		"Returns the device type.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Transmitter** (Display string: 'Transmitter'): Data stream transmitter device.\n"
		"- **Receiver** (Display string: 'Receiver'): Data stream receiver device.\n"
		"- **Transceiver** (Display string: 'Transceiver'): Data stream receiver and transmitter device.\n"
		"- **Peripheral** (Display string: 'Peripheral'): Controllable device (with no data stream handling).\n"
		"- **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a device for a mixed protocol.\n"
		"- **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a device for a custom protocol.\n"
		"- **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a device for the GigE Vision protocol.\n"
		"- **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a device for the CameraLink protocol.\n"
		"- **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a device for the CoaXPress protocol.\n"
		"- **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a device for the CameraLink HS protocol.\n"
		"- **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a device for the USB3 Vision protocol.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceModule_deviceDisplayName_get", _wrap_DeviceModule_deviceDisplayName_get, METH_O, "\n"
		"A string property. Indicates user readable name for the remote device.\n"
		"This is a read only element. It is a string that indicates user readable name for the remote device model.\n"
		""},
	 { "DeviceModule_deviceTimestampFrequency_get", _wrap_DeviceModule_deviceTimestampFrequency_get, METH_O, "\n"
		"An integer property. Indicates the tick-frequency of the timestamp clock of the remote device.\n"
		"Indicates the tick-frequency of the timestamp clock of the remote device.\n"
		""},
	 { "DeviceModule_deviceAccessStatus_get", _wrap_DeviceModule_deviceAccessStatus_get, METH_O, "\n"
		"An enumerated integer property. Indicates the current access status for the device.\n"
		"This is a read only feature. This enumeration gives the device's access status at the moment of the last execution of the DeviceUpdateList command. This value only changes on execution of the DeviceUpdateList command.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Unknown** (Display string: 'Unknown'): This enumeration value indicates that the device accessibility is not known.\n"
		"- **ReadWrite** (Display string: 'Read/Write'): This enumeration value indicates that full access to the device is available.\n"
		"- **ReadOnly** (Display string: 'Read Only'): This enumeration value indicates that read access to the device is available.\n"
		"- **NoAccess** (Display string: 'No Access'): This enumeration value indicates that no access to the device is available.\n"
		"- **Busy** (Display string: 'Busy'): This enumeration value indicates that the device is already opened by another entity.\n"
		"- **OpenReadWrite** (Display string: 'Open Read Write'): This enumeration value indicates that the device is open in Read/Write mode by this GenTL host.\n"
		"- **OpenReadOnly** (Display string: 'Open Read Only'): This enumeration value indicates that the device is open in Read only mode by this GenTL host.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceModule_deviceChunkDataFormat_get", _wrap_DeviceModule_deviceChunkDataFormat_get, METH_O, "\n"
		"An enumerated integer property. Indicates the chunk data format used by the remote device.\n"
		"This is a read only feature. This enumeration provides a value that indicates the chunk data format used by the remote device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **None** (Display string: 'None'): This enumeration value indicates that the device does not use chunk data at all.\n"
		"- **GigEVision** (Display string: 'GigE Vision'): This enumeration value indicates that the device formats the chunk data using chunk data format defined by GigE Vision specification version 1.x. The chunk data decoding algorithm (chunk adapter) common for the GigE Vision devices can be used.\n"
		"- **Custom** (Display string: 'Custom'): This enumeration value indicates that the device formats the chunk data using a custom, non-standard format. Without a-priori additional knowledge about the device and its implementation, the GenTL Consumer should always use the generic chunk adapter to decode the chunk data, not making any assumptions about the internal event data layout..\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceModule_deviceEventDataFormat_get", _wrap_DeviceModule_deviceEventDataFormat_get, METH_O, "\n"
		"An enumerated integer property. Indicates the event data format used by the remote device.\n"
		"This is a read only feature. This enumeration provides a value that indicates the event data format used by the remote device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **None** (Display string: 'None'): This enumeration value indicates that the device does not use event data at all.\n"
		"- **GigEVision** (Display string: 'GigE Vision'): This enumeration value indicates that the device formats the event data using the event data format defined by GigE Vision specification version 1.x. The event data decoding algorithm (event adapter) common for the GigE Vision devices can be used.\n"
		"- **GigEVisionExtendedId** (Display string: 'GigE Vision Extended Id'): This enumeration value indicates that the device formats the event data using the event data format defined by GigE Vision specification version 2.x. The event data decoding algorithm (event adapter) common for the GigE Vision devices can be used.\n"
		"- **Custom** (Display string: 'Custom'): This enumeration value indicates that the device formats the event data using a custom, non-standard format. Without a-priori additional knowledge about the device and its implementation, the GenTL Consumer should always use the generic event adapter to decode the event data, not making any assumptions about the internal event data layout..\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceModule_gevDeviceMACAddress_get", _wrap_DeviceModule_gevDeviceMACAddress_get, METH_O, "\n"
		"An integer property. Indicates the 48-bit MAC address of the GVCP interface of the selected remote device.\n"
		"This is a read only element. It indicates the 48-bit MAC address of the GVCP interface of the selected remote device.\n"
		""},
	 { "DeviceModule_gevDeviceIPAddress_get", _wrap_DeviceModule_gevDeviceIPAddress_get, METH_O, "\n"
		"An integer property. Indicates the current IP address of the GVCP interface of the selected remote device.\n"
		"This is a read only element. It indicates the current IP address of the GVCP interface of the selected remote device.\n"
		""},
	 { "DeviceModule_gevDeviceSubnetMask_get", _wrap_DeviceModule_gevDeviceSubnetMask_get, METH_O, "\n"
		"An integer property. Indicates the current subnet mask of the GVCP interface of the selected remote device.\n"
		"This is a read only element. It indicates the current subnet mask of the GVCP interface of the selected remote device.\n"
		""},
	 { "DeviceModule_gevDeviceGateway_get", _wrap_DeviceModule_gevDeviceGateway_get, METH_O, "\n"
		"An integer property. Indicates the current gateway of the GVCP interface of the selected remote device.\n"
		"This is a read only element. It indicates the current gateway of the GVCP interface of the selected remote device.\n"
		""},
	 { "DeviceModule_gevVersionMajor_get", _wrap_DeviceModule_gevVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the GigE Vision specification this device complies with.\n"
		"This is a read only element. It indicates the major version number of the GigE Vision specification this device complies with.\n"
		""},
	 { "DeviceModule_gevVersionMinor_get", _wrap_DeviceModule_gevVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the GigE Vision specification this device complies with.\n"
		"This is a read only element. It indicates the minor version number of the GigE Vision specification this device complies with.\n"
		""},
	 { "DeviceModule_genCPVersionMajor_get", _wrap_DeviceModule_genCPVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the GenCP specification this device complies with.\n"
		"This is a read only element. It indicates the major version number of the GenCP specification this device complies with.\n"
		""},
	 { "DeviceModule_genCPVersionMinor_get", _wrap_DeviceModule_genCPVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the GenCP specification this device complies with.\n"
		"This is a read only element. It indicates the minor version number of the GenCP specification this device complies with.\n"
		""},
	 { "DeviceModule_u3vVersionMajor_get", _wrap_DeviceModule_u3vVersionMajor_get, METH_O, "\n"
		"An integer property. Indicates the major version number of the USB3 Vision specification this device complies with.\n"
		"This is a read only element. It indicates the major version number of the USB3 Vision specification this device complies with.\n"
		""},
	 { "DeviceModule_u3vVersionMinor_get", _wrap_DeviceModule_u3vVersionMinor_get, METH_O, "\n"
		"An integer property. Indicates the minor version number of the USB3 Vision specification this device complies with.\n"
		"This is a read only element. It indicates the minor version number of the USB3 Vision specification this device complies with.\n"
		""},
	 { "DeviceModule_mvDeviceLicenseValid_get", _wrap_DeviceModule_mvDeviceLicenseValid_get, METH_O, "\n"
		"A boolean property. True if the current device has a valid license.\n"
		"True if the current device has a valid license. This is the case for all devices manufactured by the same vendor as this SDK and devices for which a license file has been provided.\n"
		""},
	 { "DeviceModule_mvDeviceLicenseDetails_get", _wrap_DeviceModule_mvDeviceLicenseDetails_get, METH_O, "\n"
		"A string property. Details about the granted license.\n"
		"This is a read only element. It indicates details whether or not this device can be operated without limitations using this driver stack.\n"
		""},
	 { "DeviceModule_deviceEndianessMechanism_get", _wrap_DeviceModule_deviceEndianessMechanism_get, METH_O, "\n"
		"An enumerated integer property. Identifies the endianess mode to be used for this device.\n"
		"This is a read only feature. This enumeration provides a value that indicates the endianess mode to be used for this device.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Legacy** (Display string: 'Legacy'): This enumeration value indicates that this device shall be handled according to GenICam Schema 1.0.\n"
		"- **Standard** (Display string: 'Standard'): This enumeration value indicates that this device shall be handled according to GenICam Schema 1.1 and later.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceModule_linkCommandTimeout_get", _wrap_DeviceModule_linkCommandTimeout_get, METH_O, "\n"
		"A floating point property. Specifies application timeout for the control channel communication.\n"
		"The feature specifies application timeout for the control channel communication. It defines the application timeout, and it is related to the device feature DeviceLinkCommandTimeout specifying the maximum time for handling a command in the device. Up to DeviceLinkCommandRetryCount attempts with this timeout are made before a command fails with a timout error.\n"
		""},
	 { "DeviceModule_mvLinkCommandTimeoutCheckGranularity_get", _wrap_DeviceModule_mvLinkCommandTimeoutCheckGranularity_get, METH_O, "\n"
		"An integer property. Indicates how often the driver shall check the link during one 'DeviceLinkCommandTimeout' interval.\n"
		"Indicates how often the driver shall check the link during one 'DeviceLinkCommandTimeout' interval. The higher this value the more often the link will be checked. However additional traffic on the link is only generated if no other communication like polling certain registers, reading or writing is performed by an application. A higher value will result in a faster notification in case a device has been physically been unplugged.\n"
		""},
	 { "DeviceModule_linkCommandRetryCount_get", _wrap_DeviceModule_linkCommandRetryCount_get, METH_O, "\n"
		"An integer property. Specifies maximum number of tries before failing the control channel commands.\n"
		"This feature specifies maximum number of tries before failing the control channel commands.\n"
		""},
	 { "DeviceModule_streamSelector_get", _wrap_DeviceModule_streamSelector_get, METH_O, "\n"
		"An integer property. Selects the stream channel.\n"
		"Selects the stream channel.\n"
		""},
	 { "DeviceModule_streamID_get", _wrap_DeviceModule_streamID_get, METH_O, "\n"
		"A string property. Device wide unique ID of the selected stream.\n"
		"This is a read only element. It is a string that indicates a device wide unique identifier of the selected stream.\n"
		""},
	 { "DeviceModule_eventSelector_get", _wrap_DeviceModule_eventSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Event to signal to the host application.\n"
		"Selects which Event to signal to the host application.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.\n"
		"- **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.\n"
		"- **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.\n"
		"- **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.\n"
		"- **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.\n"
		"- **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.\n"
		"- **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.\n"
		"- **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).\n"
		"- **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.\n"
		"- **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.\n"
		"- **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.\n"
		"- **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.\n"
		"- **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.\n"
		"- **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.\n"
		"- **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.\n"
		"- **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.\n"
		"- **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.\n"
		"- **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.\n"
		"- **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.\n"
		"- **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.\n"
		"- **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.\n"
		"- **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.\n"
		"- **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.\n"
		"- **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.\n"
		"- **DeviceTemperatureStateCritical** (Display string: 'Device Temperature State Critical')\n"
		"- **DeviceTemperatureStateNormal** (Display string: 'Device Temperature State Normal')\n"
		"- **DeviceTemperatureStateOverTemperature** (Display string: 'Device Temperature State Over Temperature')\n"
		"- **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.\n"
		"- **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.\n"
		"- **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.\n"
		"- **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.\n"
		"- **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.\n"
		"- **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.\n"
		"- **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.\n"
		"- **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.\n"
		"- **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.\n"
		"- **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.\n"
		"- **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.\n"
		"- **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.\n"
		"- **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.\n"
		"- **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.\n"
		"- **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.\n"
		"- **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.\n"
		"- **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.\n"
		"- **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.\n"
		"- **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.\n"
		"- **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.\n"
		"- **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.\n"
		"- **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.\n"
		"- **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.\n"
		"- **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.\n"
		"- **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.\n"
		"- **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.\n"
		"- **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.\n"
		"- **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.\n"
		"- **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.\n"
		"- **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.\n"
		"- **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.\n"
		"- **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.\n"
		"- **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.\n"
		"- **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.\n"
		"- **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.\n"
		"- **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.\n"
		"- **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.\n"
		"- **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.\n"
		"- **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.\n"
		"- **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.\n"
		"- **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.\n"
		"- **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.\n"
		"- **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.\n"
		"- **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.\n"
		"- **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.\n"
		"- **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.\n"
		"- **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.\n"
		"- **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.\n"
		"- **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.\n"
		"- **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.\n"
		"- **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.\n"
		"- **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.\n"
		"- **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.\n"
		"- **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.\n"
		"- **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.\n"
		"- **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.\n"
		"- **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.\n"
		"- **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.\n"
		"- **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.\n"
		"- **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.\n"
		"- **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.\n"
		"- **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.\n"
		"- **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.\n"
		"- **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.\n"
		"- **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.\n"
		"- **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.\n"
		"- **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.\n"
		"- **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.\n"
		"- **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.\n"
		"- **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.\n"
		"- **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.\n"
		"- **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.\n"
		"- **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.\n"
		"- **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.\n"
		"- **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.\n"
		"- **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.\n"
		"- **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.\n"
		"- **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.\n"
		"- **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.\n"
		"- **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.\n"
		"- **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.\n"
		"- **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.\n"
		"- **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.\n"
		"- **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.\n"
		"- **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.\n"
		"- **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.\n"
		"- **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.\n"
		"- **Link0Trigger** (Display string: 'Link 0 Trigger')\n"
		"- **Link1Trigger** (Display string: 'Link 1 Trigger')\n"
		"- **Link2Trigger** (Display string: 'Link 2 Trigger')\n"
		"- **Link3Trigger** (Display string: 'Link 3 Trigger')\n"
		"- **Link4Trigger** (Display string: 'Link 4 Trigger')\n"
		"- **Link5Trigger** (Display string: 'Link 5 Trigger')\n"
		"- **Link6Trigger** (Display string: 'Link 6 Trigger')\n"
		"- **Link7Trigger** (Display string: 'Link 7 Trigger')\n"
		"- **Link8Trigger** (Display string: 'Link 8 Trigger')\n"
		"- **Link9Trigger** (Display string: 'Link 9 Trigger')\n"
		"- **Link10Trigger** (Display string: 'Link 10 Trigger')\n"
		"- **Link11Trigger** (Display string: 'Link 11 Trigger')\n"
		"- **Link12Trigger** (Display string: 'Link 12 Trigger')\n"
		"- **Link13Trigger** (Display string: 'Link 13 Trigger')\n"
		"- **Link14Trigger** (Display string: 'Link 14 Trigger')\n"
		"- **Link15Trigger** (Display string: 'Link 15 Trigger')\n"
		"- **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.\n"
		"- **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).\n"
		"- **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.\n"
		"- **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.\n"
		"- **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.\n"
		"- **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.\n"
		"- **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.\n"
		"- **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.\n"
		"- **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.\n"
		"- **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.\n"
		"- **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.\n"
		"- **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.\n"
		"- **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.\n"
		"- **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.\n"
		"- **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.\n"
		"- **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.\n"
		"- **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.\n"
		"- **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.\n"
		"- **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.\n"
		"- **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.\n"
		"- **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.\n"
		"- **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.\n"
		"- **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.\n"
		"- **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.\n"
		"- **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.\n"
		"- **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.\n"
		"- **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DeviceModule_eventNotification_get", _wrap_DeviceModule_eventNotification_get, METH_O, "\n"
		"An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The selected Event notification is disabled.\n"
		"- **On** (Display string: 'On'): The selected Event notification is enabled.\n"
		"- **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.\n"
		"- **GigEVisionEvent** (Display string: 'Gig E Vision Event')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_DeviceModule", _wrap_delete_DeviceModule, METH_O, NULL},
	 { "DeviceModule_swigregister", DeviceModule_swigregister, METH_O, NULL},
	 { "DeviceModule_swiginit", DeviceModule_swiginit, METH_VARARGS, NULL},
	 { "new_DataStreamModule", _wrap_new_DataStreamModule, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::DataStreamModule** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type index: int\n"
		":param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "DataStreamModule_streamID_get", _wrap_DataStreamModule_streamID_get, METH_O, "\n"
		"A string property. Device wide unique ID of the selected stream.\n"
		"This is a read only element. It is a string that indicates a device wide unique identifier of the selected stream.\n"
		""},
	 { "DataStreamModule_streamType_get", _wrap_DataStreamModule_streamType_get, METH_O, "\n"
		"An enumerated integer property. Identifies the stream technology of the GenTL Producer implementation.\n"
		"This is a read only feature. This enumeration provides a value that indicates stream technology of the GenTL Producer implementation.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a data stream for a mixed protocol.\n"
		"- **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a data stream for a custom protocol.\n"
		"- **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a data stream for the GigE Vision protocol.\n"
		"- **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a data stream for the CameraLink protocol.\n"
		"- **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a data stream for the CoaXPress protocol.\n"
		"- **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a data stream for the CameraLink HS protocol.\n"
		"- **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a data stream for the USB3 Vision protocol.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DataStreamModule_mvStreamDriverTechnology_get", _wrap_DataStreamModule_mvStreamDriverTechnology_get, METH_O, "\n"
		"A string property. The underlying driver technology used by this stream.\n"
		"This is a read only element. It is a string that contains the underlying driver technology used by this stream.\n"
		""},
	 { "DataStreamModule_mvAutoJoinMulticastGroups_get", _wrap_DataStreamModule_mvAutoJoinMulticastGroups_get, METH_O, "\n"
		"A boolean property. This feature controls whether the host automatically joins the multicast group(s) of the camera(s) it configures.\n"
		"This feature controls whether the host automatically joins the multicast group(s) of the camera(s) it configures.\n"
		""},
	 { "DataStreamModule_mvResendActive_get", _wrap_DataStreamModule_mvResendActive_get, METH_O, "\n"
		"A boolean property. This feature controls if the stream will issue packet resend requests.\n"
		"This feature controls if the stream will issue packet resend requests.\n"
		""},
	 { "DataStreamModule_mvResendUserControlledEnable_get", _wrap_DataStreamModule_mvResendUserControlledEnable_get, METH_O, "\n"
		"A boolean property. This feature controls if the resend related parameters on this stream will be controlled by the driver or the host application.\n"
		"This feature controls if the resend related parameters on this stream will be controlled by the driver or the host application.\n"
		""},
	 { "DataStreamModule_mvResendMode_get", _wrap_DataStreamModule_mvResendMode_get, METH_O, "\n"
		"An integer property. Indicates the mode the internal resend algorithm is working in. This feature is a bit mask. The bits have the following meaning (LSB to MSB): Request Resends when a new block starts and the current one has missing packets(0x01)(not recommended for LAG), Request Resends when a new block starts and the current one has no trailer so far(0x02)(not recommended for LAG), Request Resends when more than 'ResendThreshold' packets have been received since a missing packet has been detected(0x04), Request Resends whenever 'mvResendResponseTimeout' did elapse for the previous still incomplete buffer(0x08), Request Resends whenever 'mvResendResponseTimeout' did elapse for the current still incomplete buffer(0x10), Request Resends whenever a packet is considered as missing(0x20)(not recommended for LAG), Request Resends whenever a block start has been missing(e.g. because no capture buffer was available at the time the block did start)(0x40)\n"
		"Indicates the mode the internal resend algorithm is working in. This feature is a bit mask. The bits have the following meaning (LSB to MSB): Request Resends when a new block starts and the current one has missing packets(0x01)(not recommended for LAG), Request Resends when a new block starts and the current one has no trailer so far(0x02)(not recommended for LAG), Request Resends when more than 'ResendThreshold' packets have been received since a missing packet has been detected(0x04), Request Resends whenever 'mvResendResponseTimeout' did elapse for the previous still incomplete buffer(0x08), Request Resends whenever 'mvResendResponseTimeout' did elapse for the current still incomplete buffer(0x10), Request Resends whenever a packet is considered as missing(0x20)(not recommended for LAG), Request Resends whenever a block start has been missing(e.g. because no capture buffer was available at the time the block did start)(0x40)\n"
		""},
	 { "DataStreamModule_mvResendBatchingActive_get", _wrap_DataStreamModule_mvResendBatchingActive_get, METH_O, "\n"
		"A boolean property. This feature controls if the stream will issue batched packet resend requests if it detects several consecutive missing packets.\n"
		"This feature controls if the stream will issue batched packet resend requests if it detects several consecutive missing packets.\n"
		""},
	 { "DataStreamModule_mvResendMaximumGapSize_get", _wrap_DataStreamModule_mvResendMaximumGapSize_get, METH_O, "\n"
		"An integer property. Defines the maximum gap between 2 consecutive packets in the stream.\n"
		"This feature defines the maximum gap between 2 consecutive packets in the stream. If a detected gap larger than 'MaximumGapSize' this block is considered as incomplete. When this parameter is 0 no gap will be considered as too big.\n"
		""},
	 { "DataStreamModule_mvResendThreshold_get", _wrap_DataStreamModule_mvResendThreshold_get, METH_O, "\n"
		"An integer property. Indicates the resend threshold within the capture window.\n"
		"This feature indicates the resend threshold within the capture window. If current packet ID and first missing packet ID are mvResendThreshold IDs apart the stream will issue a resend request.\n"
		""},
	 { "DataStreamModule_mvResendRequestMax_get", _wrap_DataStreamModule_mvResendRequestMax_get, METH_O, "\n"
		"An integer property. Indicates the maximum number of resend requests per packet to send to the device until the packet is considered as lost.\n"
		"This feature indicates the maximum number of resend requests per packet to send to the device until the packet is considered as lost.\n"
		""},
	 { "DataStreamModule_mvResendRequestCredits_get", _wrap_DataStreamModule_mvResendRequestCredits_get, METH_O, "\n"
		"A floating point property. Indicates the maximum number of resend requests in percent of payload packets per buffer to send to the device until the packet is considered as lost.\n"
		"This feature indicates the maximum number of resend requests in percent of payload packets per buffer to send to the device until the packet is considered as lost.\n"
		""},
	 { "DataStreamModule_mvResendResponseTimeout_get", _wrap_DataStreamModule_mvResendResponseTimeout_get, METH_O, "\n"
		"An integer property. This feature controls the resend response timeout in milliseconds.\n"
		"This float value sets the resend response timeout in milliseconds. Whenever a requested packet does not arrive within this timer period it will be requested again until mvResendRequestMax resend requests for this packet have been issued.\n"
		""},
	 { "DataStreamModule_mvResendsPerTimeout_get", _wrap_DataStreamModule_mvResendsPerTimeout_get, METH_O, "\n"
		"An integer property. Indicates the number of packets to be requested whenever the resend response timeout elapses.\n"
		"This feature indicates the number of packets to be requested whenever the resend response timeout elapses.\n"
		""},
	 { "DataStreamModule_mvMultiCoreAcquisitionEnable_get", _wrap_DataStreamModule_mvMultiCoreAcquisitionEnable_get, METH_O, "\n"
		"A boolean property. This feature controls whether the host shall process incoming data a single arbitrary CPU core (Off) or one or multiple dedicated ones (On).\n"
		"This feature controls whether the host shall process incoming data a single arbitrary CPU core (Off) or one or multiple dedicated ones (On)\n"
		""},
	 { "DataStreamModule_mvMultiCoreAcquisitionBaseCore_get", _wrap_DataStreamModule_mvMultiCoreAcquisitionBaseCore_get, METH_O, "\n"
		"An integer property. This feature indicates the base CPU core (as selected by the NIC) that will be used for the processing of network data for this stream.\n"
		"This feature indicates the base CPU core (as selected by the NIC) that will be used for the processing of network data for this stream. This value when added to 'mvMultiCoreAcquisitionFirstCoreIndex' will indicate the first of 'mvMultiCoreAcquisitionCoreCount' actual CPUs that will ater be used for the processing of network data for this stream\n"
		""},
	 { "DataStreamModule_mvMultiCoreAcquisitionCoreCount_get", _wrap_DataStreamModule_mvMultiCoreAcquisitionCoreCount_get, METH_O, "\n"
		"An integer property. This feature controls how many CPU cores will be used for the processing of network data for this stream.\n"
		"This feature controls how many CPU cores will be used for the processing of network data for this stream\n"
		""},
	 { "DataStreamModule_mvMultiCoreAcquisitionFirstCoreIndex_get", _wrap_DataStreamModule_mvMultiCoreAcquisitionFirstCoreIndex_get, METH_O, "\n"
		"An integer property. This feature controls which is the first CPU core to use for processing network data out of the list of CPU cores available for this task for the NIC associated with this stream.\n"
		"This feature controls which is the first CPU core to use for processing network data out of the list of CPU cores available for this task for the NIC associated with this stream. Please note that this number does NOT have a 1:1 relationship to the CPU in your system but to the CPUs available for processing on the selected NIC. So if e.g. the corresponding NICs RSS table can access CPUs 6, 8, 10 and 12 then setting 'mvMultiCoreAcquisitionFirstCoreIndex' to 2 will result in CPUs 10 and 12 to be used.\n"
		""},
	 { "DataStreamModule_mvMultiCoreAcquisitionCoreSwitchInterval_get", _wrap_DataStreamModule_mvMultiCoreAcquisitionCoreSwitchInterval_get, METH_O, "\n"
		"An integer property. This feature controls after how many network packets the processing shall switch to the next CPU core. Smaller values introduce a higher overhead, values too high might result in loss of data when the network card runs out of buffers. The recommended values are in the range of 32 - 256.\n"
		"This feature controls after how many network packets the processing shall switch to the next CPU core. Smaller values introduce a higher overhead, values too high might result in loss of data when the network card runs out of buffers. The recommended values are in the range of 32 - 256\n"
		""},
	 { "DataStreamModule_mvV4L2MemoryMode_get", _wrap_DataStreamModule_mvV4L2MemoryMode_get, METH_O, "\n"
		"An enumerated integer property. Controls which of the underlying V4L2 specific buffer memory modes will be used.\n"
		"PRELIMINARY. SUBJECT TO CHANGE WITHOUT FURTHER NOTICE. This feature controls which of the underlying V4L2 specific buffer memory modes will be used.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **mvMMAP** (Display string: 'mv MMAP'): PRELIMINARY. SUBJECT TO CHANGE WITHOUT FURTHER NOTICE. This enumeration value indicates that the acquisition engine will use the MMAP memory mode. This does NOT result in optimal performance since each image must be copied from the memory mapped buffer from kernel space into the target buffer in user space.\n"
		"- **mvUSERPTR** (Display string: 'mv USERPTR'): PRELIMINARY. SUBJECT TO CHANGE WITHOUT FURTHER NOTICE. This enumeration value indicates that the acquisition engine will use the user-pointrr memory mode.\n"
		"- **mvOVERLAY** (Display string: 'mv OVERLAY'): PRELIMINARY. SUBJECT TO CHANGE WITHOUT FURTHER NOTICE. This enumeration value indicates that the acquisition engine will use the overlay memory mode.\n"
		"- **mvDMA** (Display string: 'mv DMA'): PRELIMINARY. SUBJECT TO CHANGE WITHOUT FURTHER NOTICE. This enumeration value indicates that the acquisition engine will use the DMA memory mode.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DataStreamModule_mvMMAPBufferCount_get", _wrap_DataStreamModule_mvMMAPBufferCount_get, METH_O, "\n"
		"An integer property. The number of buffers internally used for the MMAP memory mode.\n"
		"PRELIMINARY. SUBJECT TO CHANGE WITHOUT FURTHER NOTICE. This feature defines the number of buffers internally used for the MMAP memory mode. This is NOT to be confused with the value of the 'RequestCount' property.\n"
		""},
	 { "DataStreamModule_mvLowLatencyModeEnable_get", _wrap_DataStreamModule_mvLowLatencyModeEnable_get, METH_O, "\n"
		"A boolean property. This feature controls whether the low-latency mode (NVIDIA specific) is active or not.\n"
		"PRELIMINARY. SUBJECT TO CHANGE WITHOUT FURTHER NOTICE. This feature controls whether the low-latency mode (NVIDIA specific) is active or not.\n"
		""},
	 { "DataStreamModule_streamAnnouncedBufferCount_get", _wrap_DataStreamModule_streamAnnouncedBufferCount_get, METH_O, "\n"
		"An integer property. Number of announced (known) buffers on this stream. This value is volatile. It may change if additional buffers are announced and/or buffers are revoked by the GenTL Consumer.\n"
		"This is a read-only feature. It indicates the number of announced (known) buffers on this stream. This value is volatile. It may change if additional buffers are announced and/or buffers are revoked by the GenTL Consumer.\n"
		""},
	 { "DataStreamModule_streamBufferHandlingMode_get", _wrap_DataStreamModule_streamBufferHandlingMode_get, METH_O, "\n"
		"An enumerated integer property. Allows to select the buffer handling mode for the stream.\n"
		"This enumeration allows the selection of the buffer handling mode for the stream.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **OldestFirst** (Display string: 'OldestFirst'): This enumeration value indicates that this stream is using the default acquisition mode.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DataStreamModule_streamAnnounceBufferMinimum_get", _wrap_DataStreamModule_streamAnnounceBufferMinimum_get, METH_O, "\n"
		"An integer property. Minimal number of buffers to announce to enable selected acquisition mode.\n"
		"This feature indicates the minimal number of buffers to announce to enable selected acquisition mode.\n"
		""},
	 { "DataStreamModule_mvStreamAnnounceBufferMaximum_get", _wrap_DataStreamModule_mvStreamAnnounceBufferMaximum_get, METH_O, "\n"
		"An integer property. Maximal number of buffers to announce to enable selected acquisition mode.\n"
		"This feature indicates the maximal number of buffers to announce to enable selected acquisition mode.\n"
		""},
	 { "DataStreamModule_streamDeliveredFrameCount_get", _wrap_DataStreamModule_streamDeliveredFrameCount_get, METH_O, "\n"
		"An integer property. Number of delivered frames since last acquisition start.\n"
		"This feature indicates the number of delivered frames since last acquisition start. It is not reset until the stream is closed.\n"
		""},
	 { "DataStreamModule_streamLostFrameCount_get", _wrap_DataStreamModule_streamLostFrameCount_get, METH_O, "\n"
		"An integer property. Number of lost frames due to queue underrun.\n"
		"This feature indicates the number of lost frames due to queue underrun. This number is initialized with zero at the time the stream is opened and incremented every time the data could not be acquired because there was no buffer in the input buffer pool. It is not reset until the stream is closed.\n"
		""},
	 { "DataStreamModule_streamInputBufferCount_get", _wrap_DataStreamModule_streamInputBufferCount_get, METH_O, "\n"
		"An integer property. Number of buffers in the input buffer pool plus the buffers(s) currently being filled.\n"
		"This feature indicates the number of buffers in the input buffer pool plus the buffers(s) currently being filled.\n"
		""},
	 { "DataStreamModule_streamOutputBufferCount_get", _wrap_DataStreamModule_streamOutputBufferCount_get, METH_O, "\n"
		"An integer property. Number of buffers in the output buffer queue.\n"
		"This feature indicates the number of buffers in the output buffer queue.\n"
		""},
	 { "DataStreamModule_streamStartedFrameCount_get", _wrap_DataStreamModule_streamStartedFrameCount_get, METH_O, "\n"
		"An integer property. Number of frames started in the acquisition engine.\n"
		"This feature indicates the number of frames started in the acquisition engine. This number is incremented every time in case of a new buffer is started and then to be filled (data written to) regardless even if the buffer is later delivered to the user or discarded for any reason. This number is initialized with 0 at the time the stream is opened. It is not reset until the stream is closed.\n"
		""},
	 { "DataStreamModule_payloadSize_get", _wrap_DataStreamModule_payloadSize_get, METH_O, "\n"
		"An integer property. Provides the number of bytes transferred for each data buffer or chunk on the stream channel.\n"
		"Provides the number of bytes transferred for each data buffer or chunk on the stream channel. This includes any end-of-line, end-of-frame statistics or other stamp data. This is the total size of data payload for a data block.\n"
		""},
	 { "DataStreamModule_streamIsGrabbing_get", _wrap_DataStreamModule_streamIsGrabbing_get, METH_O, "\n"
		"A boolean property. Flag indicating whether the acquisition engine is started or not.\n"
		"This feature indicates whether the acquisition engine is started or not. This is independent from the acquisition status of the remote device.\n"
		""},
	 { "DataStreamModule_streamChunkCountMaximum_get", _wrap_DataStreamModule_streamChunkCountMaximum_get, METH_O, "\n"
		"An integer property. Maximum number of chunks to be expected in a buffer (can be used to allocate the array for the DSGetBufferChunkData function).\n"
		"Maximum number of chunks to be expected in a buffer (can be used to allocate the array for the DSGetBufferChunkData function).\n"
		""},
	 { "DataStreamModule_streamBufferAlignment_get", _wrap_DataStreamModule_streamBufferAlignment_get, METH_O, "\n"
		"An integer property. Alignment size in bytes of the buffers passed to DSAnnounceBuffer.\n"
		"This feature indicates the alignment size in bytes of the buffers passed to DSAnnounceBuffer. If a buffer is passed to DSAnnounceBuffer which is not aligned according to the alignment size it is up to the Producer to either reject the buffer and return a GC_ERR_INVALID_BUFFER error code or to cope with a potential overhead and use the unaligned buffer as is.\n"
		""},
	 { "DataStreamModule_eventSelector_get", _wrap_DataStreamModule_eventSelector_get, METH_O, "\n"
		"An enumerated integer property. Selects which Event to signal to the host application.\n"
		"Selects which Event to signal to the host application.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.\n"
		"- **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.\n"
		"- **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.\n"
		"- **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.\n"
		"- **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.\n"
		"- **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.\n"
		"- **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.\n"
		"- **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.\n"
		"- **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.\n"
		"- **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.\n"
		"- **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).\n"
		"- **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).\n"
		"- **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.\n"
		"- **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.\n"
		"- **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.\n"
		"- **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.\n"
		"- **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.\n"
		"- **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.\n"
		"- **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.\n"
		"- **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.\n"
		"- **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.\n"
		"- **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.\n"
		"- **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.\n"
		"- **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.\n"
		"- **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.\n"
		"- **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.\n"
		"- **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.\n"
		"- **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.\n"
		"- **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.\n"
		"- **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.\n"
		"- **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.\n"
		"- **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.\n"
		"- **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.\n"
		"- **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.\n"
		"- **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.\n"
		"- **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.\n"
		"- **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.\n"
		"- **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.\n"
		"- **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.\n"
		"- **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.\n"
		"- **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.\n"
		"- **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.\n"
		"- **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.\n"
		"- **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.\n"
		"- **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.\n"
		"- **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.\n"
		"- **DeviceTemperatureStateCritical** (Display string: 'Device Temperature State Critical')\n"
		"- **DeviceTemperatureStateNormal** (Display string: 'Device Temperature State Normal')\n"
		"- **DeviceTemperatureStateOverTemperature** (Display string: 'Device Temperature State Over Temperature')\n"
		"- **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.\n"
		"- **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.\n"
		"- **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.\n"
		"- **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.\n"
		"- **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.\n"
		"- **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.\n"
		"- **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.\n"
		"- **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.\n"
		"- **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.\n"
		"- **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.\n"
		"- **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.\n"
		"- **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.\n"
		"- **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.\n"
		"- **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.\n"
		"- **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.\n"
		"- **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.\n"
		"- **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.\n"
		"- **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.\n"
		"- **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.\n"
		"- **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.\n"
		"- **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.\n"
		"- **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.\n"
		"- **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.\n"
		"- **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.\n"
		"- **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.\n"
		"- **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.\n"
		"- **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.\n"
		"- **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.\n"
		"- **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.\n"
		"- **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.\n"
		"- **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.\n"
		"- **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.\n"
		"- **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.\n"
		"- **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).\n"
		"- **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).\n"
		"- **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.\n"
		"- **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.\n"
		"- **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.\n"
		"- **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.\n"
		"- **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.\n"
		"- **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.\n"
		"- **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.\n"
		"- **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.\n"
		"- **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.\n"
		"- **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.\n"
		"- **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.\n"
		"- **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.\n"
		"- **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.\n"
		"- **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.\n"
		"- **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.\n"
		"- **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.\n"
		"- **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.\n"
		"- **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.\n"
		"- **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.\n"
		"- **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.\n"
		"- **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.\n"
		"- **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.\n"
		"- **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.\n"
		"- **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.\n"
		"- **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.\n"
		"- **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.\n"
		"- **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.\n"
		"- **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.\n"
		"- **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.\n"
		"- **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.\n"
		"- **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.\n"
		"- **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.\n"
		"- **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.\n"
		"- **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.\n"
		"- **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.\n"
		"- **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.\n"
		"- **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.\n"
		"- **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.\n"
		"- **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.\n"
		"- **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.\n"
		"- **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.\n"
		"- **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.\n"
		"- **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.\n"
		"- **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.\n"
		"- **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.\n"
		"- **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.\n"
		"- **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.\n"
		"- **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.\n"
		"- **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.\n"
		"- **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.\n"
		"- **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.\n"
		"- **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.\n"
		"- **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.\n"
		"- **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.\n"
		"- **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.\n"
		"- **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.\n"
		"- **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.\n"
		"- **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.\n"
		"- **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.\n"
		"- **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.\n"
		"- **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.\n"
		"- **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.\n"
		"- **Link0Trigger** (Display string: 'Link 0 Trigger')\n"
		"- **Link1Trigger** (Display string: 'Link 1 Trigger')\n"
		"- **Link2Trigger** (Display string: 'Link 2 Trigger')\n"
		"- **Link3Trigger** (Display string: 'Link 3 Trigger')\n"
		"- **Link4Trigger** (Display string: 'Link 4 Trigger')\n"
		"- **Link5Trigger** (Display string: 'Link 5 Trigger')\n"
		"- **Link6Trigger** (Display string: 'Link 6 Trigger')\n"
		"- **Link7Trigger** (Display string: 'Link 7 Trigger')\n"
		"- **Link8Trigger** (Display string: 'Link 8 Trigger')\n"
		"- **Link9Trigger** (Display string: 'Link 9 Trigger')\n"
		"- **Link10Trigger** (Display string: 'Link 10 Trigger')\n"
		"- **Link11Trigger** (Display string: 'Link 11 Trigger')\n"
		"- **Link12Trigger** (Display string: 'Link 12 Trigger')\n"
		"- **Link13Trigger** (Display string: 'Link 13 Trigger')\n"
		"- **Link14Trigger** (Display string: 'Link 14 Trigger')\n"
		"- **Link15Trigger** (Display string: 'Link 15 Trigger')\n"
		"- **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.\n"
		"- **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.\n"
		"- **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.\n"
		"- **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).\n"
		"- **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.\n"
		"- **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.\n"
		"- **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.\n"
		"- **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.\n"
		"- **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.\n"
		"- **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.\n"
		"- **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.\n"
		"- **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.\n"
		"- **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.\n"
		"- **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.\n"
		"- **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.\n"
		"- **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).\n"
		"- **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.\n"
		"- **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.\n"
		"- **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.\n"
		"- **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.\n"
		"- **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.\n"
		"- **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.\n"
		"- **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.\n"
		"- **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.\n"
		"- **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.\n"
		"- **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.\n"
		"- **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.\n"
		"- **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.\n"
		"- **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.\n"
		"- **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.\n"
		"- **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.\n"
		"- **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.\n"
		"- **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.\n"
		"- **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.\n"
		"- **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.\n"
		"- **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.\n"
		"- **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.\n"
		"- **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.\n"
		"- **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.\n"
		"- **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.\n"
		"- **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.\n"
		"- **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.\n"
		"- **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.\n"
		"- **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.\n"
		"- **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.\n"
		"- **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.\n"
		"- **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.\n"
		"- **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "DataStreamModule_eventNotification_get", _wrap_DataStreamModule_eventNotification_get, METH_O, "\n"
		"An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"Activate or deactivate the notification to the host application of the occurrence of the selected Event.\n"
		"\n"
		"The following string values might be valid for this feature:\n"
		"- **Off** (Display string: 'Off'): The selected Event notification is disabled.\n"
		"- **On** (Display string: 'On'): The selected Event notification is enabled.\n"
		"- **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.\n"
		"- **GigEVisionEvent** (Display string: 'Gig E Vision Event')\n"
		"\n"
		"Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.\n"
		"To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.\n"
		""},
	 { "delete_DataStreamModule", _wrap_delete_DataStreamModule, METH_O, NULL},
	 { "DataStreamModule_swigregister", DataStreamModule_swigregister, METH_O, NULL},
	 { "DataStreamModule_swiginit", DataStreamModule_swiginit, METH_VARARGS, NULL},
	 { "new_CustomCommandGenerator", _wrap_new_CustomCommandGenerator, METH_VARARGS, "\n"
		" Constructs a new **mvIMPACT::acquire::GenICam::CustomCommandGenerator** object.\n"
		":type pDev: :py:class:`Device`\n"
		":param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.\n"
		":type settingName: string\n"
		":param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**\n"
		""},
	 { "CustomCommandGenerator_discardCommandBuffer", _wrap_CustomCommandGenerator_discardCommandBuffer, METH_O, "\n"
		" Discards all pending custom commands to the device.\n"
		"This function will discard all pending custom commands. After calling this function\n"
		"the pending command queue will be empty an can be filled with new commands.\n"
		"\n"
		"Since: 2.18.0\n"
		""},
	 { "CustomCommandGenerator_queueTransmissionRequest", _wrap_CustomCommandGenerator_queueTransmissionRequest, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Request the transmission of an image with a certain timestamp in a different mode/ROI.\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.1\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type timestamp_us: int\n"
		":param timestamp_us: [in] The timestamp of the **mvIMPACT::acquire::Request** object shall be transmitted again.\n"
		":type offsetX: int\n"
		":param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type offsetY: int\n"
		":param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type width: int\n"
		":param width: [in] The width of the ROI of the image that shall be transmitted within the current image.\n"
		":type height: int\n"
		":param height: [in] The height of the ROI of the image that shall be transmitted within the current image.\n"
		":type mode: int\n"
		":param mode: [in] The mode in which this image shall be transmitted.\n"
		":type identifier: int\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Request the transmission of an image currently associated with the Request object in a different mode/ROI.\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.1\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":type offsetX: int\n"
		":param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type offsetY: int\n"
		":param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type width: int\n"
		":param width: [in] The width of the ROI of the image that shall be transmitted within the current image.\n"
		":type height: int\n"
		":param height: [in] The height of the ROI of the image that shall be transmitted within the current image.\n"
		":type mode: int\n"
		":param mode: [in] The mode in which this image shall be transmitted.\n"
		":type identifier: int\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Request the transmission of an image currently associated with the Request object in a different mode/ROI.\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.1\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":type offsetX: int\n"
		":param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type offsetY: int\n"
		":param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type width: int\n"
		":param width: [in] The width of the ROI of the image that shall be transmitted within the current image.\n"
		":type height: int\n"
		":param height: [in] The height of the ROI of the image that shall be transmitted within the current image.\n"
		":type mode: int\n"
		":param mode: [in] The mode in which this image shall be transmitted.\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Request the transmission of an image currently associated with the Request object in a different mode/ROI.\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.1\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":type offsetX: int\n"
		":param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type offsetY: int\n"
		":param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type width: int\n"
		":param width: [in] The width of the ROI of the image that shall be transmitted within the current image.\n"
		":type height: int\n"
		":param height: [in] The height of the ROI of the image that shall be transmitted within the current image.\n"
		":param mode: [in] The mode in which this image shall be transmitted.\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Request the transmission of an image currently associated with the Request object in full resolution.\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to queue the transmission request of the image currently associated with ``pRequest`` in full resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"The actual transmission request will not be sent to the device until **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**\n"
		"is called. With this function multiple commands can be sent to a device at once. When the new\n"
		"command does not fit inside the internal command queue any more all pending commands will be sent\n"
		"to the device before the new one is put into the queue.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**\n"
		"\n"
		"Since: 2.18.1\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":type identifier: int\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Request the transmission of an image currently associated with the Request object in full resolution.\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to queue the transmission request of the image currently associated with ``pRequest`` in full resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"The actual transmission request will not be sent to the device until **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**\n"
		"is called. With this function multiple commands can be sent to a device at once. When the new\n"
		"command does not fit inside the internal command queue any more all pending commands will be sent\n"
		"to the device before the new one is put into the queue.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**\n"
		"\n"
		"Since: 2.18.1\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		""},
	 { "CustomCommandGenerator_requestTransmission", _wrap_CustomCommandGenerator_requestTransmission, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Request the transmission of an image with a certain timestamp in a different mode/ROI.\n"
		"This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**\n"
		"directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been\n"
		"queued before and have not yet been sent will be sent as well when calling this function.\n"
		"\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.1\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type timestamp_us: int\n"
		":param timestamp_us: [in] The timestamp of the **mvIMPACT::acquire::Request** object shall be transmitted again.\n"
		":type offsetX: int\n"
		":param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type offsetY: int\n"
		":param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type width: int\n"
		":param width: [in] The width of the ROI of the image that shall be transmitted within the current image.\n"
		":type height: int\n"
		":param height: [in] The height of the ROI of the image that shall be transmitted within the current image.\n"
		":type mode: int\n"
		":param mode: [in] The mode in which this image shall be transmitted.\n"
		":type identifier: int\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Request the transmission of an image currently associated with the Request object in a different mode/ROI.\n"
		"This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**\n"
		"directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been\n"
		"queued before and have not yet been sent will be sent as well when calling this function.\n"
		"\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":type offsetX: int\n"
		":param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type offsetY: int\n"
		":param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type width: int\n"
		":param width: [in] The width of the ROI of the image that shall be transmitted within the current image.\n"
		":type height: int\n"
		":param height: [in] The height of the ROI of the image that shall be transmitted within the current image.\n"
		":type mode: int\n"
		":param mode: [in] The mode in which this image shall be transmitted.\n"
		":type identifier: int\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		" Request the transmission of an image currently associated with the Request object in a different mode/ROI.\n"
		"This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**\n"
		"directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been\n"
		"queued before and have not yet been sent will be sent as well when calling this function.\n"
		"\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":type offsetX: int\n"
		":param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type offsetY: int\n"
		":param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type width: int\n"
		":param width: [in] The width of the ROI of the image that shall be transmitted within the current image.\n"
		":type height: int\n"
		":param height: [in] The height of the ROI of the image that shall be transmitted within the current image.\n"
		":type mode: int\n"
		":param mode: [in] The mode in which this image shall be transmitted.\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 4:*\n"
		" Request the transmission of an image currently associated with the Request object in a different mode/ROI.\n"
		"This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**\n"
		"directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been\n"
		"queued before and have not yet been sent will be sent as well when calling this function.\n"
		"\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":type offsetX: int\n"
		":param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type offsetY: int\n"
		":param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.\n"
		":type width: int\n"
		":param width: [in] The width of the ROI of the image that shall be transmitted within the current image.\n"
		":type height: int\n"
		":param height: [in] The height of the ROI of the image that shall be transmitted within the current image.\n"
		":param mode: [in] The mode in which this image shall be transmitted.\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 5:*\n"
		" Request the transmission of an image currently associated with the Request object in full resolution.\n"
		"This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**\n"
		"directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been\n"
		"queued before and have not yet been sent will be sent as well when calling this function.\n"
		"\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in full resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":type identifier: int\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 6:*\n"
		" Request the transmission of an image currently associated with the Request object in full resolution.\n"
		"This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**\n"
		"directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been\n"
		"queued before and have not yet been sent will be sent as well when calling this function.\n"
		"\n"
		"If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this\n"
		"function can be used to request the transmission of the image currently associated with ``pRequest`` in full resolution.\n"
		"One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties\n"
		"**mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**\n"
		"to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission\n"
		"of the very same image in full resolution for detailed processing.\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type pRequest: :py:class:`Request`\n"
		":param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.\n"
		":param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.\n"
		""},
	 { "CustomCommandGenerator_modifySequencerSetValue", _wrap_CustomCommandGenerator_modifySequencerSetValue, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Modifies a value of a certain sequencer set at runtime.\n"
		"This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueSequencerSetValueModification**\n"
		"directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been\n"
		"queued before and have not yet been sent will be sent as well when calling this function.\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type sequencerSet: int\n"
		":param sequencerSet: The index of the sequencer set to modify.\n"
		":type parameter: int\n"
		":param parameter: The parameter within the selected sequencer set to modify.\n"
		":type value: int\n"
		":param value: The new value the selected parameter within the selected sequencer set shall be set to.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Modifies a value of a certain sequencer set at runtime.\n"
		"This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueSequencerSetValueModification**\n"
		"directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been\n"
		"queued before and have not yet been sent will be sent as well when calling this function.\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type sequencerSet: int\n"
		":param sequencerSet: The index of the sequencer set to modify.\n"
		":type parameter: int\n"
		":param parameter: The parameter within the selected sequencer set to modify.\n"
		":type value: float\n"
		":param value: The new value the selected parameter within the selected sequencer set shall be set to.\n"
		""},
	 { "CustomCommandGenerator_queueSequencerSetValueModification", _wrap_CustomCommandGenerator_queueSequencerSetValueModification, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Queues the modification of a value of a certain sequencer set at runtime.\n"
		"This function queues a single parameter modification of a selected sequencer set. The actual\n"
		"modification will not become effective until **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**\n"
		"is called. With this function multiple modifications can be sent to a device at once. When the new\n"
		"command does not fit inside the internal command queue any more all pending commands will be sent\n"
		"to the device before the new one is put into the queue.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type sequencerSet: int\n"
		":param sequencerSet: The index of the sequencer set to modify.\n"
		":type parameter: int\n"
		":param parameter: The parameter within the selected sequencer set to modify.\n"
		":type value: int\n"
		":param value: The new value the selected parameter within the selected sequencer set shall be set to.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Queues the modification of a value of a certain sequencer set at runtime.\n"
		"This function queues a single parameter modification of a selected sequencer set. The actual\n"
		"modification will not become effective until **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**\n"
		"is called. With this function multiple modifications can be sent to a device at once. When the new\n"
		"command does not fit inside the internal command queue any more all pending commands will be sent\n"
		"to the device before the new one is put into the queue.\n"
		"\n"
		"See also: \n"
		"**mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		"\n"
		":type sequencerSet: int\n"
		":param sequencerSet: The index of the sequencer set to modify.\n"
		":type parameter: int\n"
		":param parameter: The parameter within the selected sequencer set to modify.\n"
		":type value: float\n"
		":param value: The new value the selected parameter within the selected sequencer set shall be set to.\n"
		""},
	 { "CustomCommandGenerator_sendCommandBuffer", _wrap_CustomCommandGenerator_sendCommandBuffer, METH_O, "\n"
		" Applies all pending custom commands to the device.\n"
		"This function will send all pending custom commands to a device. After calling this function\n"
		"the pending command queue will be empty an can be filled with new commands. Calling this function\n"
		"multiple times without queuing new commands after each send will have no effect!\n"
		"\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.\n"
		"    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.\n"
		""},
	 { "CustomCommandGenerator_commandBufferSize", _wrap_CustomCommandGenerator_commandBufferSize, METH_O, "\n"
		" Returns the size of the command buffer for this device in bytes.\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: The size of the command buffer for this device in bytes.\n"
		""},
	 { "CustomCommandGenerator_commandBufferSizeUsed", _wrap_CustomCommandGenerator_commandBufferSizeUsed, METH_O, "\n"
		" Returns the amount of bytes of the command buffer currently used(thus the amount of bytes that await sending) for this device in bytes.\n"
		"Since: 2.18.0\n"
		"\n"
		":rtype: int\n"
		":return: The amount of bytes of the command buffer currently used(thus the amount of bytes that await sending) for this device in bytes.\n"
		""},
	 { "delete_CustomCommandGenerator", _wrap_delete_CustomCommandGenerator, METH_O, NULL},
	 { "CustomCommandGenerator_swigregister", CustomCommandGenerator_swigregister, METH_O, NULL},
	 { "CustomCommandGenerator_swiginit", CustomCommandGenerator_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};

static PyMethodDef SwigMethods_proxydocs[] = {
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_mvIMPACT__acquire__IOSubSystemCommonTo_p_mvIMPACT__acquire__IOSubSystem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::IOSubSystem *)  ((mvIMPACT::acquire::IOSubSystemCommon *) x));
}
static void *_p_mvIMPACT__acquire__IOSubSystemBlueFOXTo_p_mvIMPACT__acquire__IOSubSystem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::IOSubSystem *)  ((mvIMPACT::acquire::IOSubSystemBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__IOSubSystemFrameGrabberTo_p_mvIMPACT__acquire__IOSubSystem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::IOSubSystem *) (mvIMPACT::acquire::IOSubSystemCommon *) ((mvIMPACT::acquire::IOSubSystemFrameGrabber *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBaseTo_p_mvIMPACT__acquire__BasicDeviceSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettings *) (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) ((mvIMPACT::acquire::CameraSettingsBase *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__BasicDeviceSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettings *) (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *)(mvIMPACT::acquire::CameraSettingsBlueDevice *) ((mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__BasicDeviceSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettings *) (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *)(mvIMPACT::acquire::CameraSettingsBlueDevice *) ((mvIMPACT::acquire::CameraSettingsBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsFrameGrabberTo_p_mvIMPACT__acquire__BasicDeviceSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettings *) (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *) ((mvIMPACT::acquire::CameraSettingsFrameGrabber *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsVirtualDeviceTo_p_mvIMPACT__acquire__BasicDeviceSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettings *) (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *) ((mvIMPACT::acquire::CameraSettingsVirtualDevice *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsV4L2DeviceTo_p_mvIMPACT__acquire__BasicDeviceSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettings *) (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) ((mvIMPACT::acquire::CameraSettingsV4L2Device *) x));
}
static void *_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOITo_p_mvIMPACT__acquire__BasicDeviceSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettings *)  ((mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueDeviceTo_p_mvIMPACT__acquire__BasicDeviceSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettings *) (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *) ((mvIMPACT::acquire::CameraSettingsBlueDevice *) x));
}
static void *_p_mvIMPACT__acquire__SystemBlueFOXTo_p_mvIMPACT__acquire__SystemSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::SystemSettings *)  ((mvIMPACT::acquire::SystemBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__SystemV4L2To_p_mvIMPACT__acquire__SystemSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::SystemSettings *)  ((mvIMPACT::acquire::SystemV4L2 *) x));
}
static void *_p_mvIMPACT__acquire__InfoBlueCOUGARTo_p_mvIMPACT__acquire__InfoBlueDevice(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::InfoBlueDevice *)  ((mvIMPACT::acquire::InfoBlueCOUGAR *) x));
}
static void *_p_mvIMPACT__acquire__InfoBlueFOXTo_p_mvIMPACT__acquire__InfoBlueDevice(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::InfoBlueDevice *)  ((mvIMPACT::acquire::InfoBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__CameraSettingsBlueDevice(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraSettingsBlueDevice *)  ((mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__CameraSettingsBlueDevice(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraSettingsBlueDevice *)  ((mvIMPACT::acquire::CameraSettingsBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__InfoBlueCOUGARTo_p_mvIMPACT__acquire__Info(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Info *) (mvIMPACT::acquire::InfoBlueDevice *) ((mvIMPACT::acquire::InfoBlueCOUGAR *) x));
}
static void *_p_mvIMPACT__acquire__InfoBlueFOXTo_p_mvIMPACT__acquire__Info(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Info *) (mvIMPACT::acquire::InfoBlueDevice *) ((mvIMPACT::acquire::InfoBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__InfoBlueDeviceTo_p_mvIMPACT__acquire__Info(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Info *)  ((mvIMPACT::acquire::InfoBlueDevice *) x));
}
static void *_p_mvIMPACT__acquire__EValTooLargeTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValTooLarge *) x));
}
static void *_p_mvIMPACT__acquire__EIncompatibleComponentsTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EIncompatibleComponents *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EInvalidValue *) x));
}
static void *_p_mvIMPACT__acquire__EValidationFailedTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValidationFailed *) x));
}
static void *_p_mvIMPACT__acquire__ENoReadRightsTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENoReadRights *) x));
}
static void *_p_mvIMPACT__acquire__EWrongParamCountTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EWrongParamCount *) x));
}
static void *_p_mvIMPACT__acquire__EComponentNotFoundTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EComponentNotFound *) x));
}
static void *_p_mvIMPACT__acquire__EUnsupportedOperationTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EUnsupportedOperation *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTypeTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EInvalidValueType *) x));
}
static void *_p_mvIMPACT__acquire__ENoWriteRightsTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENoWriteRights *) x));
}
static void *_p_mvIMPACT__acquire__ENoModifySizeRightsTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENoModifySizeRights *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::ETranslationTableCorrupted *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidParameterListTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EMethod *) ((mvIMPACT::acquire::EInvalidParameterList *) x));
}
static void *_p_mvIMPACT__acquire__EMethodTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EMethod *) x));
}
static void *_p_mvIMPACT__acquire__ENotAMethodTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENotAMethod *) x));
}
static void *_p_mvIMPACT__acquire__ECantRegisterComponentTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::ECantRegisterComponent *) x));
}
static void *_p_mvIMPACT__acquire__EComponentTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EComponent *) x));
}
static void *_p_mvIMPACT__acquire__ENotAListTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENotAList *) x));
}
static void *_p_mvIMPACT__acquire__ESizeMismatchTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::ESizeMismatch *) x));
}
static void *_p_mvIMPACT__acquire__EListEntryOccupiedTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EListEntryOccupied *) x));
}
static void *_p_mvIMPACT__acquire__ECantAccessDataTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::ECantAccessData *) x));
}
static void *_p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EMethod *) ((mvIMPACT::acquire::EMethodPtrInvalid *) x));
}
static void *_p_mvIMPACT__acquire__EComponentIDInvalidTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EComponentIDInvalid *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::ETranslationTableNotDefined *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidInputParameterTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EInvalidInputParameter *) x));
}
static void *_p_mvIMPACT__acquire__EUnsupportedParameterTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EUnsupportedParameter *) x));
}
static void *_p_mvIMPACT__acquire__ENotAPropertyTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENotAProperty *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EProperty *) x));
}
static void *_p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValIDOutOfBounds *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyHandlingTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *)  ((mvIMPACT::acquire::EPropertyHandling *) x));
}
static void *_p_mvIMPACT__acquire__EInputBufferTooSmallTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EInputBufferTooSmall *) x));
}
static void *_p_mvIMPACT__acquire__EValTooSmallTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValTooSmall *) x));
}
static void *_p_mvIMPACT__acquire__EImplementationMissingTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EImplementationMissing *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyListTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EPropertyList *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidFileContentTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EInvalidFileContent *) x));
}
static void *_p_mvIMPACT__acquire__ECantSerializeDataTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::ECantSerializeData *) x));
}
static void *_p_mvIMPACT__acquire__ECantAllocateNewListTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::ECantAllocateNewList *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidListIDTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *) (mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EInvalidListID *) x));
}
static void *_p_mvIMPACT__acquire__EDeviceManagerTo_p_mvIMPACT__acquire__ImpactAcquireException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ImpactAcquireException *)  ((mvIMPACT::acquire::EDeviceManager *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionDigitalBaseTo_p_mvIMPACT__acquire__CameraDescriptionBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionBase *)  ((mvIMPACT::acquire::CameraDescriptionDigitalBase *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionCameraLinkTo_p_mvIMPACT__acquire__CameraDescriptionBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionBase *) (mvIMPACT::acquire::CameraDescriptionDigitalBase *)(mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) ((mvIMPACT::acquire::CameraDescriptionCameraLink *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionDigitalTo_p_mvIMPACT__acquire__CameraDescriptionBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionBase *) (mvIMPACT::acquire::CameraDescriptionDigitalBase *)(mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) ((mvIMPACT::acquire::CameraDescriptionDigital *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionStandardBaseTo_p_mvIMPACT__acquire__CameraDescriptionBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionBase *)  ((mvIMPACT::acquire::CameraDescriptionStandardBase *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2To_p_mvIMPACT__acquire__CameraDescriptionBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionBase *) (mvIMPACT::acquire::CameraDescriptionDigitalBase *) ((mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionStandardTo_p_mvIMPACT__acquire__CameraDescriptionBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionBase *) (mvIMPACT::acquire::CameraDescriptionStandardBase *) ((mvIMPACT::acquire::CameraDescriptionStandard *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionNonStandardTo_p_mvIMPACT__acquire__CameraDescriptionBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionBase *) (mvIMPACT::acquire::CameraDescriptionStandardBase *) ((mvIMPACT::acquire::CameraDescriptionNonStandard *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionSDITo_p_mvIMPACT__acquire__CameraDescriptionBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionBase *) (mvIMPACT::acquire::CameraDescriptionDigitalBase *) ((mvIMPACT::acquire::CameraDescriptionSDI *) x));
}
static void *_p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_mvIMPACT__acquire__EMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EMethod *)  ((mvIMPACT::acquire::EMethodPtrInvalid *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidParameterListTo_p_mvIMPACT__acquire__EMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EMethod *)  ((mvIMPACT::acquire::EInvalidParameterList *) x));
}
static void *_p_mvIMPACT__acquire__EValTooLargeTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValTooLarge *) x));
}
static void *_p_mvIMPACT__acquire__EIncompatibleComponentsTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EIncompatibleComponents *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EInvalidValue *) x));
}
static void *_p_mvIMPACT__acquire__EValidationFailedTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValidationFailed *) x));
}
static void *_p_mvIMPACT__acquire__EWrongParamCountTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::EWrongParamCount *) x));
}
static void *_p_mvIMPACT__acquire__ENoReadRightsTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENoReadRights *) x));
}
static void *_p_mvIMPACT__acquire__EComponentNotFoundTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EComponentNotFound *) x));
}
static void *_p_mvIMPACT__acquire__EUnsupportedOperationTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::EUnsupportedOperation *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTypeTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EInvalidValueType *) x));
}
static void *_p_mvIMPACT__acquire__ENoWriteRightsTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENoWriteRights *) x));
}
static void *_p_mvIMPACT__acquire__ENoModifySizeRightsTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENoModifySizeRights *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::ETranslationTableCorrupted *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidParameterListTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EMethod *) ((mvIMPACT::acquire::EInvalidParameterList *) x));
}
static void *_p_mvIMPACT__acquire__EMethodTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EMethod *) x));
}
static void *_p_mvIMPACT__acquire__ENotAMethodTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENotAMethod *) x));
}
static void *_p_mvIMPACT__acquire__ECantRegisterComponentTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::ECantRegisterComponent *) x));
}
static void *_p_mvIMPACT__acquire__EComponentTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::EComponent *) x));
}
static void *_p_mvIMPACT__acquire__ENotAListTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENotAList *) x));
}
static void *_p_mvIMPACT__acquire__ESizeMismatchTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::ESizeMismatch *) x));
}
static void *_p_mvIMPACT__acquire__EListEntryOccupiedTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EListEntryOccupied *) x));
}
static void *_p_mvIMPACT__acquire__ECantAccessDataTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::ECantAccessData *) x));
}
static void *_p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EMethod *) ((mvIMPACT::acquire::EMethodPtrInvalid *) x));
}
static void *_p_mvIMPACT__acquire__EComponentIDInvalidTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EComponentIDInvalid *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::ETranslationTableNotDefined *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidInputParameterTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::EInvalidInputParameter *) x));
}
static void *_p_mvIMPACT__acquire__EUnsupportedParameterTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::EUnsupportedParameter *) x));
}
static void *_p_mvIMPACT__acquire__ENotAPropertyTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENotAProperty *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EProperty *) x));
}
static void *_p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValIDOutOfBounds *) x));
}
static void *_p_mvIMPACT__acquire__EInputBufferTooSmallTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::EInputBufferTooSmall *) x));
}
static void *_p_mvIMPACT__acquire__EValTooSmallTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValTooSmall *) x));
}
static void *_p_mvIMPACT__acquire__EImplementationMissingTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::EImplementationMissing *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyListTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EPropertyList *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidFileContentTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::EInvalidFileContent *) x));
}
static void *_p_mvIMPACT__acquire__ECantSerializeDataTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::ECantSerializeData *) x));
}
static void *_p_mvIMPACT__acquire__ECantAllocateNewListTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *)  ((mvIMPACT::acquire::ECantAllocateNewList *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidListIDTo_p_mvIMPACT__acquire__EPropertyHandling(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyHandling *) (mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EInvalidListID *) x));
}
static void *_p_mvIMPACT__acquire__ECantRegisterComponentTo_p_mvIMPACT__acquire__EPropertyList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyList *)  ((mvIMPACT::acquire::ECantRegisterComponent *) x));
}
static void *_p_mvIMPACT__acquire__EComponentNotFoundTo_p_mvIMPACT__acquire__EPropertyList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyList *)  ((mvIMPACT::acquire::EComponentNotFound *) x));
}
static void *_p_mvIMPACT__acquire__EComponentIDInvalidTo_p_mvIMPACT__acquire__EPropertyList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyList *)  ((mvIMPACT::acquire::EComponentIDInvalid *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidListIDTo_p_mvIMPACT__acquire__EPropertyList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyList *)  ((mvIMPACT::acquire::EInvalidListID *) x));
}
static void *_p_mvIMPACT__acquire__EListEntryOccupiedTo_p_mvIMPACT__acquire__EPropertyList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyList *)  ((mvIMPACT::acquire::EListEntryOccupied *) x));
}
static void *_p_mvIMPACT__acquire__ECantAccessDataTo_p_mvIMPACT__acquire__EPropertyList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EPropertyList *)  ((mvIMPACT::acquire::ECantAccessData *) x));
}
static void *_p_mvIMPACT__acquire__BasicDeviceSettingsTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::BasicDeviceSettings *) x));
}
static void *_p_mvIMPACT__acquire__WhiteBalanceSettingsTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::WhiteBalanceSettings *) x));
}
static void *_p_mvIMPACT__acquire__SystemSettingsTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::SystemSettings *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2To_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::CameraDescriptionBase *)(mvIMPACT::acquire::CameraDescriptionDigitalBase *) ((mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) x));
}
static void *_p_mvIMPACT__acquire__ImageDestinationTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::ImageDestination *) x));
}
static void *_p_mvIMPACT__acquire__AutoControlParametersTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::AutoControlParameters *) x));
}
static void *_p_mvIMPACT__acquire__GainOffsetKneeChannelParametersTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GainOffsetKneeChannelParameters *) x));
}
static void *_p_mvIMPACT__acquire__LUTParametersTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::LUTParameters *) x));
}
static void *_p_mvIMPACT__acquire__MirrorParametersTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::MirrorParameters *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueDeviceTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::BasicDeviceSettings *)(mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *) ((mvIMPACT::acquire::CameraSettingsBlueDevice *) x));
}
static void *_p_mvIMPACT__acquire__InfoBlueDeviceTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::Info *) ((mvIMPACT::acquire::InfoBlueDevice *) x));
}
static void *_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOITo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::BasicDeviceSettings *) ((mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *) x));
}
static void *_p_mvIMPACT__acquire__PulseStartConfigurationTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::PulseStartConfiguration *) x));
}
static void *_p_mvIMPACT__acquire__RequestInfoConfigurationTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::RequestInfoConfiguration *) x));
}
static void *_p_mvIMPACT__acquire__HDRControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::HDRControl *) x));
}
static void *_p_mvIMPACT__acquire__ImageRequestControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::ImageRequestControl *) x));
}
static void *_p_mvIMPACT__acquire__TriggerControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::TriggerControl *) x));
}
static void *_p_mvIMPACT__acquire__HDRKneePointTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::HDRKneePoint *) x));
}
static void *_p_mvIMPACT__acquire__I2CControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::I2CControl *) x));
}
static void *_p_mvIMPACT__acquire__MotorFocusControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::MotorFocusControl *) x));
}
static void *_p_mvIMPACT__acquire__DigitalIOMeasurementControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::DigitalIOMeasurementControl *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvAutoFeatureControl *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__DepthControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::DepthControl *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__mvLogicGateControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvLogicGateControl *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__mvCurrentControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvCurrentControl *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__mvLensControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvLensControl *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__mvFFCControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvFFCControl *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__mvFrameAverageControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvFrameAverageControl *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__mvHDRControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvHDRControl *) x));
}
static void *_p_mvIMPACT__acquire__RTCtrProgramStepTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::RTCtrProgramStep *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBaseTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::BasicDeviceSettings *)(mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) ((mvIMPACT::acquire::CameraSettingsBase *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionSDITo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::CameraDescriptionBase *)(mvIMPACT::acquire::CameraDescriptionDigitalBase *) ((mvIMPACT::acquire::CameraDescriptionSDI *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionCameraLinkTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::CameraDescriptionBase *)(mvIMPACT::acquire::CameraDescriptionDigitalBase *)(mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) ((mvIMPACT::acquire::CameraDescriptionCameraLink *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionDigitalTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::CameraDescriptionBase *)(mvIMPACT::acquire::CameraDescriptionDigitalBase *)(mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) ((mvIMPACT::acquire::CameraDescriptionDigital *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__GenTLProducerConfigurationTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *) x));
}
static void *_p_mvIMPACT__acquire__StatisticsTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::Statistics *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControlTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *) x));
}
static void *_p_mvIMPACT__acquire__ImageProcessingTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::ImageProcessing *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::BasicDeviceSettings *)(mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *)(mvIMPACT::acquire::CameraSettingsBlueDevice *) ((mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) x));
}
static void *_p_mvIMPACT__acquire__InfoBlueCOUGARTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::Info *)(mvIMPACT::acquire::InfoBlueDevice *) ((mvIMPACT::acquire::InfoBlueCOUGAR *) x));
}
static void *_p_mvIMPACT__acquire__BufferPartTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::BufferPart *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionStandardBaseTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::CameraDescriptionBase *) ((mvIMPACT::acquire::CameraDescriptionStandardBase *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__SystemModuleTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::SystemModule *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__InterfaceModuleTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::InterfaceModule *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__DeviceModuleTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::DeviceModule *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__DataStreamModuleTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::DataStreamModule *) x));
}
static void *_p_mvIMPACT__acquire__InfoTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::Info *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsFrameGrabberTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::BasicDeviceSettings *)(mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *) ((mvIMPACT::acquire::CameraSettingsFrameGrabber *) x));
}
static void *_p_mvIMPACT__acquire__SyncOutputTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::SyncOutput *) x));
}
static void *_p_mvIMPACT__acquire__GenICam__GenTLDriverConfiguratorTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsV4L2DeviceTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::BasicDeviceSettings *)(mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) ((mvIMPACT::acquire::CameraSettingsV4L2Device *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsVirtualDeviceTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::BasicDeviceSettings *)(mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *) ((mvIMPACT::acquire::CameraSettingsVirtualDevice *) x));
}
static void *_p_mvIMPACT__acquire__SystemV4L2To_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::SystemSettings *) ((mvIMPACT::acquire::SystemV4L2 *) x));
}
static void *_p_mvIMPACT__acquire__RTCtrProgramTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::RTCtrProgram *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::BasicDeviceSettings *)(mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)(mvIMPACT::acquire::CameraSettingsBase *)(mvIMPACT::acquire::CameraSettingsBlueDevice *) ((mvIMPACT::acquire::CameraSettingsBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__InfoBlueFOXTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::Info *)(mvIMPACT::acquire::InfoBlueDevice *) ((mvIMPACT::acquire::InfoBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionDigitalBaseTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::CameraDescriptionBase *) ((mvIMPACT::acquire::CameraDescriptionDigitalBase *) x));
}
static void *_p_mvIMPACT__acquire__SystemBlueFOXTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::SystemSettings *) ((mvIMPACT::acquire::SystemBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__ConnectorTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::Connector *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionStandardTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::CameraDescriptionBase *)(mvIMPACT::acquire::CameraDescriptionStandardBase *) ((mvIMPACT::acquire::CameraDescriptionStandard *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionNonStandardTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *) (mvIMPACT::acquire::CameraDescriptionBase *)(mvIMPACT::acquire::CameraDescriptionStandardBase *) ((mvIMPACT::acquire::CameraDescriptionNonStandard *) x));
}
static void *_p_mvIMPACT__acquire__ImageMemoryManagerTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::ImageMemoryManager *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionBaseTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::CameraDescriptionBase *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__CameraSettingsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraSettingsBase *) (mvIMPACT::acquire::CameraSettingsBlueDevice *) ((mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__CameraSettingsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraSettingsBase *) (mvIMPACT::acquire::CameraSettingsBlueDevice *) ((mvIMPACT::acquire::CameraSettingsBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsFrameGrabberTo_p_mvIMPACT__acquire__CameraSettingsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraSettingsBase *)  ((mvIMPACT::acquire::CameraSettingsFrameGrabber *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsVirtualDeviceTo_p_mvIMPACT__acquire__CameraSettingsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraSettingsBase *)  ((mvIMPACT::acquire::CameraSettingsVirtualDevice *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueDeviceTo_p_mvIMPACT__acquire__CameraSettingsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraSettingsBase *)  ((mvIMPACT::acquire::CameraSettingsBlueDevice *) x));
}
static void *_p_mvIMPACT__acquire__SettingsBlueFOXTo_p_mvIMPACT__acquire__FullSettingsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::FullSettingsBase *)  ((mvIMPACT::acquire::SettingsBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__SettingsFrameGrabberTo_p_mvIMPACT__acquire__FullSettingsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::FullSettingsBase *)  ((mvIMPACT::acquire::SettingsFrameGrabber *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBaseTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)  ((mvIMPACT::acquire::CameraSettingsBase *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) (mvIMPACT::acquire::CameraSettingsBase *)(mvIMPACT::acquire::CameraSettingsBlueDevice *) ((mvIMPACT::acquire::CameraSettingsBlueCOUGAR *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) (mvIMPACT::acquire::CameraSettingsBase *)(mvIMPACT::acquire::CameraSettingsBlueDevice *) ((mvIMPACT::acquire::CameraSettingsBlueFOX *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsFrameGrabberTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) (mvIMPACT::acquire::CameraSettingsBase *) ((mvIMPACT::acquire::CameraSettingsFrameGrabber *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsVirtualDeviceTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) (mvIMPACT::acquire::CameraSettingsBase *) ((mvIMPACT::acquire::CameraSettingsVirtualDevice *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsV4L2DeviceTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)  ((mvIMPACT::acquire::CameraSettingsV4L2Device *) x));
}
static void *_p_mvIMPACT__acquire__CameraSettingsBlueDeviceTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::BasicDeviceSettingsWithAOI *) (mvIMPACT::acquire::CameraSettingsBase *) ((mvIMPACT::acquire::CameraSettingsBlueDevice *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyFT_double_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyF< double > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_int_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< int > *) x));
}
static void *_p_mvIMPACT__acquire__PropertyPtrTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::PropertyPtr *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI64< enum mvIMPACT::acquire::TBufferPartDataType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI64< enum mvIMPACT::acquire::TDeviceTriggerOverlap > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::THWUpdateResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFlatFieldFilterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFieldGateMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalSignal > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalOutputControlMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalIOMeasurementSource > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalIOMeasurementMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigIOState > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceTriggerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceTriggerInterface > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceSyncOutMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceState > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceScanRateMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDevicePowerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceLoadSettings > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceInterfaceLayout > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceImageTrigger > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceDigitalOutputMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceClass > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceCapability > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceAdvancedOptions > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceAccessMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDefectivePixelsFilterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDarkCurrentFilterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorProcessingMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TClampMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TChannelSplitMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTriggerSource > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTriggerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTestMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTapsYGeometry > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTapsXGeometry > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraShutterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraSerialPortBaudRate > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraScanMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraPixelClock > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerMosaicParity > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerConversionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoOffsetCalibration > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoGainControl > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoExposureControl > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoControlMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoControlSpeed > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAoiMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionField > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerWhiteBalanceResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXFooterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXSensorTiming > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXTransferSize > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBoolean > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraAoiMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraBinningMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraDataFormat > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExposeMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExternalSyncEdge > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExternalSyncOutput > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraFlashMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraFlashType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraHDRMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraInterlacedType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraLinkDataValidMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraOutput > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TI2COperationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TI2COperationStatus > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageBufferPixelFormat > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageDestinationPixelFormat > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingFilter > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingOptimization > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestImageMemoryMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageRequestControlMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInfoSensorColorMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInfoSensorType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterlacedMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLineCounter > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTGammaMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTImplementation > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTInterpolationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTMapping > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMemoryManagerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMemoryManagerPoolMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMirrorMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMirrorOperationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TOnBoardMemoryMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPolarizedDataExtractionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPulseStartTrigger > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestState > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRTCtrlModes > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRTProgOpCodes > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScalerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScalerInterpolationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScanClock > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScanStandard > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TTriggerMoment > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TUserDataAccessRight > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TUserDataReconnectBehaviour > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVideoStandard > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVirtualDeviceImageType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVirtualDeviceTestMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TWhiteBalanceParameter > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyI64T_long_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI64< long > *) x));
}
static void *_p_mvIMPACT__acquire__PropertySTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::PropertyS *) x));
}
static void *_p_mvIMPACT__acquire__EValidationFailedTo_p_mvIMPACT__acquire__EProperty(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EProperty *)  ((mvIMPACT::acquire::EValidationFailed *) x));
}
static void *_p_mvIMPACT__acquire__EValTooSmallTo_p_mvIMPACT__acquire__EProperty(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EProperty *)  ((mvIMPACT::acquire::EValTooSmall *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTo_p_mvIMPACT__acquire__EProperty(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EProperty *)  ((mvIMPACT::acquire::EInvalidValue *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_mvIMPACT__acquire__EProperty(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EProperty *)  ((mvIMPACT::acquire::ETranslationTableCorrupted *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_mvIMPACT__acquire__EProperty(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EProperty *)  ((mvIMPACT::acquire::ETranslationTableNotDefined *) x));
}
static void *_p_mvIMPACT__acquire__EValTooLargeTo_p_mvIMPACT__acquire__EProperty(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EProperty *)  ((mvIMPACT::acquire::EValTooLarge *) x));
}
static void *_p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_mvIMPACT__acquire__EProperty(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EProperty *)  ((mvIMPACT::acquire::EValIDOutOfBounds *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTypeTo_p_mvIMPACT__acquire__EProperty(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EProperty *)  ((mvIMPACT::acquire::EInvalidValueType *) x));
}
static void *_p_mvIMPACT__acquire__EValTooLargeTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValTooLarge *) x));
}
static void *_p_mvIMPACT__acquire__EIncompatibleComponentsTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EIncompatibleComponents *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EInvalidValue *) x));
}
static void *_p_mvIMPACT__acquire__EValidationFailedTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValidationFailed *) x));
}
static void *_p_mvIMPACT__acquire__ENoReadRightsTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENoReadRights *) x));
}
static void *_p_mvIMPACT__acquire__EWrongParamCountTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EWrongParamCount *) x));
}
static void *_p_mvIMPACT__acquire__EComponentNotFoundTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EComponentNotFound *) x));
}
static void *_p_mvIMPACT__acquire__EUnsupportedOperationTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EUnsupportedOperation *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTypeTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EInvalidValueType *) x));
}
static void *_p_mvIMPACT__acquire__ENoWriteRightsTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENoWriteRights *) x));
}
static void *_p_mvIMPACT__acquire__ENoModifySizeRightsTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENoModifySizeRights *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::ETranslationTableCorrupted *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidParameterListTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EMethod *) ((mvIMPACT::acquire::EInvalidParameterList *) x));
}
static void *_p_mvIMPACT__acquire__EMethodTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EMethod *) x));
}
static void *_p_mvIMPACT__acquire__ENotAMethodTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENotAMethod *) x));
}
static void *_p_mvIMPACT__acquire__ECantRegisterComponentTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::ECantRegisterComponent *) x));
}
static void *_p_mvIMPACT__acquire__EComponentTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EComponent *) x));
}
static void *_p_mvIMPACT__acquire__ENotAListTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENotAList *) x));
}
static void *_p_mvIMPACT__acquire__ESizeMismatchTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::ESizeMismatch *) x));
}
static void *_p_mvIMPACT__acquire__EListEntryOccupiedTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EListEntryOccupied *) x));
}
static void *_p_mvIMPACT__acquire__ECantAccessDataTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::ECantAccessData *) x));
}
static void *_p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EMethod *) ((mvIMPACT::acquire::EMethodPtrInvalid *) x));
}
static void *_p_mvIMPACT__acquire__EComponentIDInvalidTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EComponentIDInvalid *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::ETranslationTableNotDefined *) x));
}
static void *_p_mvIMPACT__acquire__ImpactAcquireExceptionTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *)  ((mvIMPACT::acquire::ImpactAcquireException *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidInputParameterTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EInvalidInputParameter *) x));
}
static void *_p_mvIMPACT__acquire__EUnsupportedParameterTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EUnsupportedParameter *) x));
}
static void *_p_mvIMPACT__acquire__ENotAPropertyTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::ENotAProperty *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EProperty *) x));
}
static void *_p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValIDOutOfBounds *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyHandlingTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *) ((mvIMPACT::acquire::EPropertyHandling *) x));
}
static void *_p_mvIMPACT__acquire__EValTooSmallTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValTooSmall *) x));
}
static void *_p_mvIMPACT__acquire__EInputBufferTooSmallTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EInputBufferTooSmall *) x));
}
static void *_p_mvIMPACT__acquire__EImplementationMissingTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EImplementationMissing *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyListTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *) ((mvIMPACT::acquire::EPropertyList *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidFileContentTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::EInvalidFileContent *) x));
}
static void *_p_mvIMPACT__acquire__ECantSerializeDataTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::ECantSerializeData *) x));
}
static void *_p_mvIMPACT__acquire__ECantAllocateNewListTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *) ((mvIMPACT::acquire::ECantAllocateNewList *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidListIDTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *)(mvIMPACT::acquire::EPropertyHandling *)(mvIMPACT::acquire::EComponent *)(mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EInvalidListID *) x));
}
static void *_p_mvIMPACT__acquire__EDeviceManagerTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *) (mvIMPACT::acquire::ImpactAcquireException *) ((mvIMPACT::acquire::EDeviceManager *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionCameraLinkTo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionDigitalBase *) (mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) ((mvIMPACT::acquire::CameraDescriptionCameraLink *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionDigitalTo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionDigitalBase *) (mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) ((mvIMPACT::acquire::CameraDescriptionDigital *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2To_p_mvIMPACT__acquire__CameraDescriptionDigitalBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionDigitalBase *)  ((mvIMPACT::acquire::CameraDescriptionDigitalBase2 *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionSDITo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionDigitalBase *)  ((mvIMPACT::acquire::CameraDescriptionSDI *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyFT_double_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyF< double > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_int_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< int > *) x));
}
static void *_p_mvIMPACT__acquire__PropertyPtrTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::PropertyPtr *) x));
}
static void *_p_mvIMPACT__acquire__MethodTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *)  ((mvIMPACT::acquire::Method *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI64< enum mvIMPACT::acquire::TBufferPartDataType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI64< enum mvIMPACT::acquire::TDeviceTriggerOverlap > *) x));
}
static void *_p_mvIMPACT__acquire__PropertyTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *)  ((mvIMPACT::acquire::Property *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFieldGateMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalSignal > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalOutputControlMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalIOMeasurementSource > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalIOMeasurementMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigIOState > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceTriggerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceTriggerInterface > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceSyncOutMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceState > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceScanRateMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDevicePowerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceLoadSettings > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceInterfaceLayout > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceImageTrigger > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceDigitalOutputMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceClass > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceCapability > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceAdvancedOptions > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceAccessMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDefectivePixelsFilterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDarkCurrentFilterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorProcessingMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TClampMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TChannelSplitMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTriggerSource > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTriggerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTestMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTapsYGeometry > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTapsXGeometry > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraShutterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraSerialPortBaudRate > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraScanMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraPixelClock > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraOutput > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraLinkDataValidMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraInterlacedType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoGainControl > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoExposureControl > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoControlMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoControlSpeed > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAoiMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionField > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoOffsetCalibration > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerConversionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerMosaicParity > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerWhiteBalanceResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXFooterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXSensorTiming > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXTransferSize > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBoolean > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraAoiMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraBinningMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraDataFormat > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExposeMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExternalSyncEdge > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExternalSyncOutput > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraFlashMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraFlashType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraHDRMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFlatFieldFilterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::THWUpdateResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TI2COperationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TI2COperationStatus > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageBufferPixelFormat > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageDestinationPixelFormat > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingFilter > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingOptimization > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestImageMemoryMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageRequestControlMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInfoSensorColorMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInfoSensorType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterlacedMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLineCounter > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTGammaMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTImplementation > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTInterpolationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTMapping > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMemoryManagerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMemoryManagerPoolMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMirrorMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMirrorOperationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TOnBoardMemoryMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPolarizedDataExtractionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPulseStartTrigger > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestState > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRTCtrlModes > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRTProgOpCodes > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScalerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScalerInterpolationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScanClock > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScanStandard > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TTriggerMoment > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TUserDataAccessRight > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TUserDataReconnectBehaviour > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVideoStandard > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVirtualDeviceImageType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVirtualDeviceTestMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TWhiteBalanceParameter > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyI64T_long_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI64< long > *) x));
}
static void *_p_mvIMPACT__acquire__PropertySTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::PropertyS *) x));
}
static void *_p_mvIMPACT__acquire__ComponentListTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *)  ((mvIMPACT::acquire::ComponentList *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTypeTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EInvalidValueType *) x));
}
static void *_p_mvIMPACT__acquire__EValidationFailedTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValidationFailed *) x));
}
static void *_p_mvIMPACT__acquire__EComponentIDInvalidTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EComponentIDInvalid *) x));
}
static void *_p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EMethod *) ((mvIMPACT::acquire::EMethodPtrInvalid *) x));
}
static void *_p_mvIMPACT__acquire__ENotAMethodTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::ENotAMethod *) x));
}
static void *_p_mvIMPACT__acquire__ENoReadRightsTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::ENoReadRights *) x));
}
static void *_p_mvIMPACT__acquire__EValTooSmallTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValTooSmall *) x));
}
static void *_p_mvIMPACT__acquire__EMethodTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::EMethod *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyListTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::EPropertyList *) x));
}
static void *_p_mvIMPACT__acquire__ECantRegisterComponentTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::ECantRegisterComponent *) x));
}
static void *_p_mvIMPACT__acquire__EValTooLargeTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValTooLarge *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidValueTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EInvalidValue *) x));
}
static void *_p_mvIMPACT__acquire__ECantAccessDataTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::ECantAccessData *) x));
}
static void *_p_mvIMPACT__acquire__EComponentNotFoundTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EComponentNotFound *) x));
}
static void *_p_mvIMPACT__acquire__EListEntryOccupiedTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EListEntryOccupied *) x));
}
static void *_p_mvIMPACT__acquire__EIncompatibleComponentsTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::EIncompatibleComponents *) x));
}
static void *_p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::EValIDOutOfBounds *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::ETranslationTableCorrupted *) x));
}
static void *_p_mvIMPACT__acquire__EPropertyTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::EProperty *) x));
}
static void *_p_mvIMPACT__acquire__ENotAPropertyTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::ENotAProperty *) x));
}
static void *_p_mvIMPACT__acquire__ENotAListTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::ENotAList *) x));
}
static void *_p_mvIMPACT__acquire__ENoModifySizeRightsTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::ENoModifySizeRights *) x));
}
static void *_p_mvIMPACT__acquire__ENoWriteRightsTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *)  ((mvIMPACT::acquire::ENoWriteRights *) x));
}
static void *_p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EProperty *) ((mvIMPACT::acquire::ETranslationTableNotDefined *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidListIDTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EPropertyList *) ((mvIMPACT::acquire::EInvalidListID *) x));
}
static void *_p_mvIMPACT__acquire__EInvalidParameterListTo_p_mvIMPACT__acquire__EComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::EComponent *) (mvIMPACT::acquire::EMethod *) ((mvIMPACT::acquire::EInvalidParameterList *) x));
}
static void *_p_mvIMPACT__acquire__ComponentLocatorTo_p_mvIMPACT__acquire__ComponentLocatorBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentLocatorBase *)  ((mvIMPACT::acquire::ComponentLocator *) x));
}
static void *_p_mvIMPACT__acquire__DeviceComponentLocatorTo_p_mvIMPACT__acquire__ComponentLocatorBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentLocatorBase *)  ((mvIMPACT::acquire::DeviceComponentLocator *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionCameraLinkTo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionDigitalBase2 *)  ((mvIMPACT::acquire::CameraDescriptionCameraLink *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionDigitalTo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionDigitalBase2 *)  ((mvIMPACT::acquire::CameraDescriptionDigital *) x));
}
static void *_p_mvIMPACT__acquire__IOSubSystemFrameGrabberTo_p_mvIMPACT__acquire__IOSubSystemCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::IOSubSystemCommon *)  ((mvIMPACT::acquire::IOSubSystemFrameGrabber *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionStandardTo_p_mvIMPACT__acquire__CameraDescriptionStandardBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionStandardBase *)  ((mvIMPACT::acquire::CameraDescriptionStandard *) x));
}
static void *_p_mvIMPACT__acquire__CameraDescriptionNonStandardTo_p_mvIMPACT__acquire__CameraDescriptionStandardBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::CameraDescriptionStandardBase *)  ((mvIMPACT::acquire::CameraDescriptionNonStandard *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyFT_double_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyF< double > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_int_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< int > *) x));
}
static void *_p_mvIMPACT__acquire__PropertyPtrTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::PropertyPtr *) x));
}
static void *_p_mvIMPACT__acquire__MethodTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *) ((mvIMPACT::acquire::Method *) x));
}
static void *_p_mvIMPACT__acquire__ComponentLocatorBaseTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *)  ((mvIMPACT::acquire::ComponentLocatorBase *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI64< enum mvIMPACT::acquire::TBufferPartDataType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI64< enum mvIMPACT::acquire::TDeviceTriggerOverlap > *) x));
}
static void *_p_mvIMPACT__acquire__ComponentTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *)  ((mvIMPACT::acquire::Component *) x));
}
static void *_p_mvIMPACT__acquire__PropertyTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *) ((mvIMPACT::acquire::Property *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalIOMeasurementMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigIOState > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceTriggerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceTriggerInterface > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceSyncOutMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceState > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceScanRateMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDevicePowerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceLoadSettings > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceInterfaceLayout > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceImageTrigger > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceDigitalOutputMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceClass > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceCapability > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceAdvancedOptions > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceAccessMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDefectivePixelsFilterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDarkCurrentFilterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorProcessingMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TClampMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TChannelSplitMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTriggerSource > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTriggerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTestMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTapsYGeometry > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTapsXGeometry > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraShutterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraSerialPortBaudRate > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraScanMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraPixelClock > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraOutput > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraLinkDataValidMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraInterlacedType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraHDRMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraFlashType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraFlashMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExternalSyncOutput > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAoiMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionField > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoControlSpeed > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoControlMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoExposureControl > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoGainControl > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoOffsetCalibration > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerConversionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerMosaicParity > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerWhiteBalanceResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXFooterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXSensorTiming > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXTransferSize > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBoolean > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraAoiMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraBinningMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraDataFormat > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExposeMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExternalSyncEdge > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalIOMeasurementSource > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalOutputControlMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalSignal > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFieldGateMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFlatFieldFilterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::THWUpdateResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TI2COperationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TI2COperationStatus > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageBufferPixelFormat > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageDestinationPixelFormat > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingFilter > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingOptimization > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestImageMemoryMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageRequestControlMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInfoSensorColorMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInfoSensorType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterlacedMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLineCounter > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTGammaMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTImplementation > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTInterpolationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTMapping > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMemoryManagerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMemoryManagerPoolMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMirrorMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMirrorOperationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TOnBoardMemoryMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPolarizedDataExtractionMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPulseStartTrigger > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestResult > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestState > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRTCtrlModes > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRTProgOpCodes > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScalerMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScalerInterpolationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScanClock > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScanStandard > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TTriggerMoment > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TUserDataAccessRight > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TUserDataReconnectBehaviour > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVideoStandard > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVirtualDeviceImageType > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVirtualDeviceTestMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TWhiteBalanceParameter > *) x));
}
static void *_p_mvIMPACT__acquire__DeviceComponentLocatorTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::ComponentLocatorBase *) ((mvIMPACT::acquire::DeviceComponentLocator *) x));
}
static void *_p_mvIMPACT__acquire__ComponentLocatorTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::ComponentLocatorBase *) ((mvIMPACT::acquire::ComponentLocator *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyI64T_long_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI64< long > *) x));
}
static void *_p_mvIMPACT__acquire__PropertySTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::PropertyS *) x));
}
static void *_p_mvIMPACT__acquire__ComponentListTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *) ((mvIMPACT::acquire::ComponentList *) x));
}
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_first_type = {"_p_first_type", "first_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *|mvIMPACT::acquire::HOBJ *|mvIMPACT::acquire::HLIST *|mvIMPACT::acquire::HDRV *|mvIMPACT::acquire::HDEV *|mvIMPACT::acquire::HDMR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int16_t = {"_p_int16_t", "mvIMPACT::acquire::GenICam::int16_type *|int16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int32_t = {"_p_int32_t", "mvIMPACT::acquire::GenICam::int32_type *|int32_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "int64_type *|long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__AutoControlParameters = {"_p_mvIMPACT__acquire__AutoControlParameters", "mvIMPACT::acquire::AutoControlParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__BasicDeviceSettings = {"_p_mvIMPACT__acquire__BasicDeviceSettings", "mvIMPACT::acquire::BasicDeviceSettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI = {"_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI", "mvIMPACT::acquire::BasicDeviceSettingsWithAOI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__BufferPart = {"_p_mvIMPACT__acquire__BufferPart", "mvIMPACT::acquire::BufferPart *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionBase = {"_p_mvIMPACT__acquire__CameraDescriptionBase", "mvIMPACT::acquire::CameraDescriptionBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionCameraLink = {"_p_mvIMPACT__acquire__CameraDescriptionCameraLink", "mvIMPACT::acquire::CameraDescriptionCameraLink *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionDigital = {"_p_mvIMPACT__acquire__CameraDescriptionDigital", "mvIMPACT::acquire::CameraDescriptionDigital *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase = {"_p_mvIMPACT__acquire__CameraDescriptionDigitalBase", "mvIMPACT::acquire::CameraDescriptionDigitalBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase2 = {"_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2", "mvIMPACT::acquire::CameraDescriptionDigitalBase2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionManager = {"_p_mvIMPACT__acquire__CameraDescriptionManager", "mvIMPACT::acquire::CameraDescriptionManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionNonStandard = {"_p_mvIMPACT__acquire__CameraDescriptionNonStandard", "mvIMPACT::acquire::CameraDescriptionNonStandard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionSDI = {"_p_mvIMPACT__acquire__CameraDescriptionSDI", "mvIMPACT::acquire::CameraDescriptionSDI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionStandard = {"_p_mvIMPACT__acquire__CameraDescriptionStandard", "mvIMPACT::acquire::CameraDescriptionStandard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraDescriptionStandardBase = {"_p_mvIMPACT__acquire__CameraDescriptionStandardBase", "mvIMPACT::acquire::CameraDescriptionStandardBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraSettingsBase = {"_p_mvIMPACT__acquire__CameraSettingsBase", "mvIMPACT::acquire::CameraSettingsBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR = {"_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR", "mvIMPACT::acquire::CameraSettingsBlueCOUGAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraSettingsBlueDevice = {"_p_mvIMPACT__acquire__CameraSettingsBlueDevice", "mvIMPACT::acquire::CameraSettingsBlueDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraSettingsBlueFOX = {"_p_mvIMPACT__acquire__CameraSettingsBlueFOX", "mvIMPACT::acquire::CameraSettingsBlueFOX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraSettingsFrameGrabber = {"_p_mvIMPACT__acquire__CameraSettingsFrameGrabber", "mvIMPACT::acquire::CameraSettingsFrameGrabber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraSettingsV4L2Device = {"_p_mvIMPACT__acquire__CameraSettingsV4L2Device", "mvIMPACT::acquire::CameraSettingsV4L2Device *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__CameraSettingsVirtualDevice = {"_p_mvIMPACT__acquire__CameraSettingsVirtualDevice", "mvIMPACT::acquire::CameraSettingsVirtualDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ChannelData = {"_p_mvIMPACT__acquire__ChannelData", "mvIMPACT::acquire::ChannelData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__Component = {"_p_mvIMPACT__acquire__Component", "mvIMPACT::acquire::Component *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ComponentAccess = {"_p_mvIMPACT__acquire__ComponentAccess", "mvIMPACT::acquire::ComponentAccess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ComponentCallback = {"_p_mvIMPACT__acquire__ComponentCallback", "mvIMPACT::acquire::ComponentCallback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ComponentCollection = {"_p_mvIMPACT__acquire__ComponentCollection", "mvIMPACT::acquire::ComponentCollection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ComponentList = {"_p_mvIMPACT__acquire__ComponentList", "mvIMPACT::acquire::ComponentList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ComponentLocator = {"_p_mvIMPACT__acquire__ComponentLocator", "mvIMPACT::acquire::ComponentLocator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ComponentLocatorBase = {"_p_mvIMPACT__acquire__ComponentLocatorBase", "mvIMPACT::acquire::ComponentLocatorBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__Connector = {"_p_mvIMPACT__acquire__Connector", "mvIMPACT::acquire::Connector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__Device = {"_p_mvIMPACT__acquire__Device", "mvIMPACT::acquire::Device *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__DeviceComponentLocator = {"_p_mvIMPACT__acquire__DeviceComponentLocator", "mvIMPACT::acquire::DeviceComponentLocator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__DeviceManager = {"_p_mvIMPACT__acquire__DeviceManager", "mvIMPACT::acquire::DeviceManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__DigitalIOMeasurementControl = {"_p_mvIMPACT__acquire__DigitalIOMeasurementControl", "mvIMPACT::acquire::DigitalIOMeasurementControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__DigitalInput = {"_p_mvIMPACT__acquire__DigitalInput", "mvIMPACT::acquire::DigitalInput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__DigitalOutput = {"_p_mvIMPACT__acquire__DigitalOutput", "mvIMPACT::acquire::DigitalOutput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ECantAccessData = {"_p_mvIMPACT__acquire__ECantAccessData", "mvIMPACT::acquire::ECantAccessData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ECantAllocateNewList = {"_p_mvIMPACT__acquire__ECantAllocateNewList", "mvIMPACT::acquire::ECantAllocateNewList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ECantRegisterComponent = {"_p_mvIMPACT__acquire__ECantRegisterComponent", "mvIMPACT::acquire::ECantRegisterComponent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ECantSerializeData = {"_p_mvIMPACT__acquire__ECantSerializeData", "mvIMPACT::acquire::ECantSerializeData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EComponent = {"_p_mvIMPACT__acquire__EComponent", "mvIMPACT::acquire::EComponent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EComponentIDInvalid = {"_p_mvIMPACT__acquire__EComponentIDInvalid", "mvIMPACT::acquire::EComponentIDInvalid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EComponentNotFound = {"_p_mvIMPACT__acquire__EComponentNotFound", "mvIMPACT::acquire::EComponentNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EDeviceManager = {"_p_mvIMPACT__acquire__EDeviceManager", "mvIMPACT::acquire::EDeviceManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EImplementationMissing = {"_p_mvIMPACT__acquire__EImplementationMissing", "mvIMPACT::acquire::EImplementationMissing *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EIncompatibleComponents = {"_p_mvIMPACT__acquire__EIncompatibleComponents", "mvIMPACT::acquire::EIncompatibleComponents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EInputBufferTooSmall = {"_p_mvIMPACT__acquire__EInputBufferTooSmall", "mvIMPACT::acquire::EInputBufferTooSmall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EInvalidFileContent = {"_p_mvIMPACT__acquire__EInvalidFileContent", "mvIMPACT::acquire::EInvalidFileContent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EInvalidInputParameter = {"_p_mvIMPACT__acquire__EInvalidInputParameter", "mvIMPACT::acquire::EInvalidInputParameter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EInvalidListID = {"_p_mvIMPACT__acquire__EInvalidListID", "mvIMPACT::acquire::EInvalidListID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EInvalidParameterList = {"_p_mvIMPACT__acquire__EInvalidParameterList", "mvIMPACT::acquire::EInvalidParameterList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EInvalidValue = {"_p_mvIMPACT__acquire__EInvalidValue", "mvIMPACT::acquire::EInvalidValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EInvalidValueType = {"_p_mvIMPACT__acquire__EInvalidValueType", "mvIMPACT::acquire::EInvalidValueType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EListEntryOccupied = {"_p_mvIMPACT__acquire__EListEntryOccupied", "mvIMPACT::acquire::EListEntryOccupied *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EMethod = {"_p_mvIMPACT__acquire__EMethod", "mvIMPACT::acquire::EMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EMethodPtrInvalid = {"_p_mvIMPACT__acquire__EMethodPtrInvalid", "mvIMPACT::acquire::EMethodPtrInvalid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ENoModifySizeRights = {"_p_mvIMPACT__acquire__ENoModifySizeRights", "mvIMPACT::acquire::ENoModifySizeRights *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ENoReadRights = {"_p_mvIMPACT__acquire__ENoReadRights", "mvIMPACT::acquire::ENoReadRights *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ENoWriteRights = {"_p_mvIMPACT__acquire__ENoWriteRights", "mvIMPACT::acquire::ENoWriteRights *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ENotAList = {"_p_mvIMPACT__acquire__ENotAList", "mvIMPACT::acquire::ENotAList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ENotAMethod = {"_p_mvIMPACT__acquire__ENotAMethod", "mvIMPACT::acquire::ENotAMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ENotAProperty = {"_p_mvIMPACT__acquire__ENotAProperty", "mvIMPACT::acquire::ENotAProperty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EProperty = {"_p_mvIMPACT__acquire__EProperty", "mvIMPACT::acquire::EProperty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EPropertyHandling = {"_p_mvIMPACT__acquire__EPropertyHandling", "mvIMPACT::acquire::EPropertyHandling *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EPropertyList = {"_p_mvIMPACT__acquire__EPropertyList", "mvIMPACT::acquire::EPropertyList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ESizeMismatch = {"_p_mvIMPACT__acquire__ESizeMismatch", "mvIMPACT::acquire::ESizeMismatch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ETranslationTableCorrupted = {"_p_mvIMPACT__acquire__ETranslationTableCorrupted", "mvIMPACT::acquire::ETranslationTableCorrupted *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ETranslationTableNotDefined = {"_p_mvIMPACT__acquire__ETranslationTableNotDefined", "mvIMPACT::acquire::ETranslationTableNotDefined *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EUnsupportedOperation = {"_p_mvIMPACT__acquire__EUnsupportedOperation", "mvIMPACT::acquire::EUnsupportedOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EUnsupportedParameter = {"_p_mvIMPACT__acquire__EUnsupportedParameter", "mvIMPACT::acquire::EUnsupportedParameter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EValIDOutOfBounds = {"_p_mvIMPACT__acquire__EValIDOutOfBounds", "mvIMPACT::acquire::EValIDOutOfBounds *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EValTooLarge = {"_p_mvIMPACT__acquire__EValTooLarge", "mvIMPACT::acquire::EValTooLarge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EValTooSmall = {"_p_mvIMPACT__acquire__EValTooSmall", "mvIMPACT::acquire::EValTooSmall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EValidationFailed = {"_p_mvIMPACT__acquire__EValidationFailed", "mvIMPACT::acquire::EValidationFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EWrongParamCount = {"_p_mvIMPACT__acquire__EWrongParamCount", "mvIMPACT::acquire::EWrongParamCount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyFT_double_t = {"_p_mvIMPACT__acquire__EnumPropertyFT_double_t", "mvIMPACT::acquire::PropertyF *|mvIMPACT::acquire::EnumPropertyF< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyI64T_long_t = {"_p_mvIMPACT__acquire__EnumPropertyI64T_long_t", "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *|mvIMPACT::acquire::EnumPropertyI64< long > *|mvIMPACT::acquire::PropertyI64 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t = {"_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t", "mvIMPACT::acquire::PropertyI64BufferPartDataType *|mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType > *|mvIMPACT::acquire::EnumPropertyI64< enum mvIMPACT::acquire::TBufferPartDataType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t = {"_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t", "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *|mvIMPACT::acquire::EnumPropertyI64< enum mvIMPACT::acquire::TDeviceTriggerOverlap > *|mvIMPACT::acquire::PropertyI64DeviceTriggerOverlap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_int_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_int_t", "mvIMPACT::acquire::EnumPropertyI< int > *|mvIMPACT::acquire::PropertyI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionField > *|mvIMPACT::acquire::PropertyIAcquisitionField *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionMode > *|mvIMPACT::acquire::PropertyIAcquisitionMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *|mvIMPACT::acquire::PropertyIAcquisitionStartStopBehaviour *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAoiMode > *|mvIMPACT::acquire::PropertyIAoiMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoControlMode > *|mvIMPACT::acquire::PropertyIAutoControlMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoControlSpeed > *|mvIMPACT::acquire::PropertyIAutoControlSpeed *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t", "mvIMPACT::acquire::PropertyIAutoExposureControl *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoExposureControl > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t", "mvIMPACT::acquire::PropertyIAutoGainControl *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoGainControl > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TAutoOffsetCalibration > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *|mvIMPACT::acquire::PropertyIAutoOffsetCalibration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerConversionMode > *|mvIMPACT::acquire::PropertyIBayerConversionMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerMosaicParity > *|mvIMPACT::acquire::PropertyIBayerMosaicParity *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBayerWhiteBalanceResult > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *|mvIMPACT::acquire::PropertyIBayerWhiteBalanceResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *|mvIMPACT::acquire::PropertyIBlueFOXDigitalInputThreshold *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXFooterMode > *|mvIMPACT::acquire::PropertyIBlueFOXFooterMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *|mvIMPACT::acquire::PropertyIBlueFOXInfoSensorCapabilities *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *|mvIMPACT::acquire::PropertyIBlueFOXOffsetAutoBlackSpeed *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXSensorTiming > *|mvIMPACT::acquire::PropertyIBlueFOXSensorTiming *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t", "mvIMPACT::acquire::PropertyIBlueFOXTransferSize *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBlueFOXTransferSize > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBoolean > *|mvIMPACT::acquire::PropertyIBoolean *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraAoiMode > *|mvIMPACT::acquire::PropertyICameraAoiMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraBinningMode > *|mvIMPACT::acquire::PropertyICameraBinningMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraDataFormat > *|mvIMPACT::acquire::PropertyICameraDataFormat *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExposeMode > *|mvIMPACT::acquire::PropertyICameraExposeMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExternalSyncEdge > *|mvIMPACT::acquire::PropertyICameraExternalSyncEdge *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraExternalSyncOutput > *|mvIMPACT::acquire::PropertyICameraExternalSyncOutput *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraFlashMode > *|mvIMPACT::acquire::PropertyICameraFlashMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t", "mvIMPACT::acquire::PropertyICameraFlashType *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraFlashType > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraHDRMode > *|mvIMPACT::acquire::PropertyICameraHDRMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t", "mvIMPACT::acquire::PropertyICameraInterlacedType *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraInterlacedType > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraLinkDataValidMode > *|mvIMPACT::acquire::PropertyICameraLinkDataValidMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraOutput > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *|mvIMPACT::acquire::PropertyICameraOutput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraPixelClock > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *|mvIMPACT::acquire::PropertyICameraPixelClock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraScanMode > *|mvIMPACT::acquire::PropertyICameraScanMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t", "mvIMPACT::acquire::PropertyICameraSerialPortBaudRate *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraSerialPortBaudRate > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraShutterMode > *|mvIMPACT::acquire::PropertyICameraShutterMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTapsXGeometry > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *|mvIMPACT::acquire::PropertyICameraTapsXGeometry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTapsYGeometry > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *|mvIMPACT::acquire::PropertyICameraTapsYGeometry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTestMode > *|mvIMPACT::acquire::PropertyICameraTestMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTriggerMode > *|mvIMPACT::acquire::PropertyICameraTriggerMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TCameraTriggerSource > *|mvIMPACT::acquire::PropertyICameraTriggerSource *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TChannelSplitMode > *|mvIMPACT::acquire::PropertyIChannelSplitMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TClampMode > *|mvIMPACT::acquire::PropertyIClampMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorProcessingMode > *|mvIMPACT::acquire::PropertyIColorProcessingMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *|mvIMPACT::acquire::PropertyIColorTwistInputCorrectionMatrixMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t", "mvIMPACT::acquire::PropertyIColorTwistOutputCorrectionMatrixMode *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDarkCurrentFilterMode > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *|mvIMPACT::acquire::PropertyIDarkCurrentFilterMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t", "mvIMPACT::acquire::PropertyIDefectivePixelsFilterMode *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDefectivePixelsFilterMode > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceAccessMode > *|mvIMPACT::acquire::PropertyIDeviceAccessMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceAdvancedOptions > *|mvIMPACT::acquire::PropertyIDeviceAdvancedOptions *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAutoNegotiatePacketSizeMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAutoNegotiatePacketSizeMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceAutoNegotiatePacketSizeMode > *|mvIMPACT::acquire::PropertyIDeviceAutoNegotiatePacketSizeMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceCapability > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *|mvIMPACT::acquire::PropertyIDeviceCapability *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceClass > *|mvIMPACT::acquire::PropertyIDeviceClass *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceDigitalOutputMode > *|mvIMPACT::acquire::PropertyIDeviceDigitalOutputMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceImageTrigger > *|mvIMPACT::acquire::PropertyIDeviceImageTrigger *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceInterfaceLayout > *|mvIMPACT::acquire::PropertyIDeviceInterfaceLayout *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceLoadSettings > *|mvIMPACT::acquire::PropertyIDeviceLoadSettings *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDevicePowerMode > *|mvIMPACT::acquire::PropertyIDevicePowerMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceScanRateMode > *|mvIMPACT::acquire::PropertyIDeviceScanRateMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *|mvIMPACT::acquire::PropertyIDeviceSignalOutputStartEvent *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceState > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *|mvIMPACT::acquire::PropertyIDeviceState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceSyncOutMode > *|mvIMPACT::acquire::PropertyIDeviceSyncOutMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t", "mvIMPACT::acquire::PropertyIDeviceTriggerInterface *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceTriggerInterface > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceTriggerMode > *|mvIMPACT::acquire::PropertyIDeviceTriggerMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigIOState > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *|mvIMPACT::acquire::PropertyIDigIOState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalIOMeasurementMode > *|mvIMPACT::acquire::PropertyIDigitalIOMeasurementMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalIOMeasurementSource > *|mvIMPACT::acquire::PropertyIDigitalIOMeasurementSource *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalOutputControlMode > *|mvIMPACT::acquire::PropertyIDigitalOutputControlMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDigitalSignal > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *|mvIMPACT::acquire::PropertyIDigitalSignal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFieldGateMode > *|mvIMPACT::acquire::PropertyIFieldGateMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *|mvIMPACT::acquire::PropertyIFlatFieldFilterCorrectionMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TFlatFieldFilterMode > *|mvIMPACT::acquire::PropertyIFlatFieldFilterMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::THWUpdateResult > *|mvIMPACT::acquire::PropertyIHWUpdateResult *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TI2COperationMode > *|mvIMPACT::acquire::PropertyII2COperationMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TI2COperationStatus > *|mvIMPACT::acquire::PropertyII2COperationStatus *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *|mvIMPACT::acquire::PropertyIImageBufferFormatReinterpreterMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageBufferPixelFormat > *|mvIMPACT::acquire::PropertyIImageBufferPixelFormat *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageDestinationPixelFormat > *|mvIMPACT::acquire::PropertyIImageDestinationPixelFormat *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingFilter > *|mvIMPACT::acquire::PropertyIImageProcessingFilter *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingMode > *|mvIMPACT::acquire::PropertyIImageProcessingMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingOptimization > *|mvIMPACT::acquire::PropertyIImageProcessingOptimization *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageProcessingResult > *|mvIMPACT::acquire::PropertyIImageProcessingResult *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TImageRequestControlMode > *|mvIMPACT::acquire::PropertyIImageRequestControlMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInfoSensorColorMode > *|mvIMPACT::acquire::PropertyIInfoSensorColorMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t", "mvIMPACT::acquire::PropertyIInfoSensorType *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInfoSensorType > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *|mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterlacedMode > *|mvIMPACT::acquire::PropertyIInterlacedMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTGammaMode > *|mvIMPACT::acquire::PropertyILUTGammaMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTImplementation > *|mvIMPACT::acquire::PropertyILUTImplementation *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTInterpolationMode > *|mvIMPACT::acquire::PropertyILUTInterpolationMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTMapping > *|mvIMPACT::acquire::PropertyILUTMapping *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLUTMode > *|mvIMPACT::acquire::PropertyILUTMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TLineCounter > *|mvIMPACT::acquire::PropertyILineCounter *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMemoryManagerMode > *|mvIMPACT::acquire::PropertyIMemoryManagerMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMemoryManagerPoolMode > *|mvIMPACT::acquire::PropertyIMemoryManagerPoolMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMirrorMode > *|mvIMPACT::acquire::PropertyIMirrorMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TMirrorOperationMode > *|mvIMPACT::acquire::PropertyIMirrorOperationMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TOnBoardMemoryMode > *|mvIMPACT::acquire::PropertyIOnBoardMemoryMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *|mvIMPACT::acquire::PropertyIPolarizedDataExtractionInterpolationMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPolarizedDataExtractionMode > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *|mvIMPACT::acquire::PropertyIPolarizedDataExtractionMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TPulseStartTrigger > *|mvIMPACT::acquire::PropertyIPulseStartTrigger *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t", "mvIMPACT::acquire::PropertyIRTCtrlModes *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRTCtrlModes > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t", "mvIMPACT::acquire::PropertyIRTProgOpCodes *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRTProgOpCodes > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestImageMemoryMode > *|mvIMPACT::acquire::PropertyIRequestImageMemoryMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestResult > *|mvIMPACT::acquire::PropertyIRequestResult *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TRequestState > *|mvIMPACT::acquire::PropertyIRequestState *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScalerInterpolationMode > *|mvIMPACT::acquire::PropertyIScalerInterpolationMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScalerMode > *|mvIMPACT::acquire::PropertyIScalerMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScanClock > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *|mvIMPACT::acquire::PropertyIScanClock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TScanStandard > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *|mvIMPACT::acquire::PropertyIScanStandard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TTriggerMoment > *|mvIMPACT::acquire::PropertyITriggerMoment *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TUserDataAccessRight > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *|mvIMPACT::acquire::PropertyIUserDataAccessRight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TUserDataReconnectBehaviour > *|mvIMPACT::acquire::PropertyIUserDataReconnectBehaviour *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVideoStandard > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *|mvIMPACT::acquire::PropertyIVideoStandard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVirtualDeviceImageType > *|mvIMPACT::acquire::PropertyIVirtualDeviceImageType *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TVirtualDeviceTestMode > *|mvIMPACT::acquire::PropertyIVirtualDeviceTestMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *|mvIMPACT::acquire::PropertyIWhiteBalanceCalibrationMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TWhiteBalanceParameter > *|mvIMPACT::acquire::PropertyIWhiteBalanceParameter *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ExceptionFactory = {"_p_mvIMPACT__acquire__ExceptionFactory", "mvIMPACT::acquire::ExceptionFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__FirmwareUpdater = {"_p_mvIMPACT__acquire__FirmwareUpdater", "mvIMPACT::acquire::FirmwareUpdater *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__FullSettingsBase = {"_p_mvIMPACT__acquire__FullSettingsBase", "mvIMPACT::acquire::FullSettingsBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__FunctionInterface = {"_p_mvIMPACT__acquire__FunctionInterface", "mvIMPACT::acquire::FunctionInterface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GainOffsetKneeChannelParameters = {"_p_mvIMPACT__acquire__GainOffsetKneeChannelParameters", "mvIMPACT::acquire::GainOffsetKneeChannelParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__AcquisitionControl = {"_p_mvIMPACT__acquire__GenICam__AcquisitionControl", "mvIMPACT::acquire::GenICam::AcquisitionControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__ActionControl = {"_p_mvIMPACT__acquire__GenICam__ActionControl", "mvIMPACT::acquire::GenICam::ActionControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__AnalogControl = {"_p_mvIMPACT__acquire__GenICam__AnalogControl", "mvIMPACT::acquire::GenICam::AnalogControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__ChunkDataControl = {"_p_mvIMPACT__acquire__GenICam__ChunkDataControl", "mvIMPACT::acquire::GenICam::ChunkDataControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__ColorTransformationControl = {"_p_mvIMPACT__acquire__GenICam__ColorTransformationControl", "mvIMPACT::acquire::GenICam::ColorTransformationControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__CounterAndTimerControl = {"_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl", "mvIMPACT::acquire::GenICam::CounterAndTimerControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__CustomCommandGenerator = {"_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator", "mvIMPACT::acquire::GenICam::CustomCommandGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__DataStreamModule = {"_p_mvIMPACT__acquire__GenICam__DataStreamModule", "mvIMPACT::acquire::GenICam::DataStreamModule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__DepthControl = {"_p_mvIMPACT__acquire__GenICam__DepthControl", "mvIMPACT::acquire::GenICam::DepthControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__DeviceControl = {"_p_mvIMPACT__acquire__GenICam__DeviceControl", "mvIMPACT::acquire::GenICam::DeviceControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__DeviceModule = {"_p_mvIMPACT__acquire__GenICam__DeviceModule", "mvIMPACT::acquire::GenICam::DeviceModule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__DigitalIOControl = {"_p_mvIMPACT__acquire__GenICam__DigitalIOControl", "mvIMPACT::acquire::GenICam::DigitalIOControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__EncoderControl = {"_p_mvIMPACT__acquire__GenICam__EncoderControl", "mvIMPACT::acquire::GenICam::EncoderControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__EventControl = {"_p_mvIMPACT__acquire__GenICam__EventControl", "mvIMPACT::acquire::GenICam::EventControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__FileAccessControl = {"_p_mvIMPACT__acquire__GenICam__FileAccessControl", "mvIMPACT::acquire::GenICam::FileAccessControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator = {"_p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator", "mvIMPACT::acquire::GenICam::GenTLDriverConfigurator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration = {"_p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration", "mvIMPACT::acquire::GenICam::GenTLProducerConfiguration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__ImageFormatControl = {"_p_mvIMPACT__acquire__GenICam__ImageFormatControl", "mvIMPACT::acquire::GenICam::ImageFormatControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__InterfaceModule = {"_p_mvIMPACT__acquire__GenICam__InterfaceModule", "mvIMPACT::acquire::GenICam::InterfaceModule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__LUTControl = {"_p_mvIMPACT__acquire__GenICam__LUTControl", "mvIMPACT::acquire::GenICam::LUTControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__LightControl = {"_p_mvIMPACT__acquire__GenICam__LightControl", "mvIMPACT::acquire::GenICam::LightControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__LogicBlockControl = {"_p_mvIMPACT__acquire__GenICam__LogicBlockControl", "mvIMPACT::acquire::GenICam::LogicBlockControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__OpticControl = {"_p_mvIMPACT__acquire__GenICam__OpticControl", "mvIMPACT::acquire::GenICam::OpticControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__Scan3dControl = {"_p_mvIMPACT__acquire__GenICam__Scan3dControl", "mvIMPACT::acquire::GenICam::Scan3dControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__SequencerControl = {"_p_mvIMPACT__acquire__GenICam__SequencerControl", "mvIMPACT::acquire::GenICam::SequencerControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__SoftwareSignalControl = {"_p_mvIMPACT__acquire__GenICam__SoftwareSignalControl", "mvIMPACT::acquire::GenICam::SoftwareSignalControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__SourceControl = {"_p_mvIMPACT__acquire__GenICam__SourceControl", "mvIMPACT::acquire::GenICam::SourceControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__SystemModule = {"_p_mvIMPACT__acquire__GenICam__SystemModule", "mvIMPACT::acquire::GenICam::SystemModule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__TestControl = {"_p_mvIMPACT__acquire__GenICam__TestControl", "mvIMPACT::acquire::GenICam::TestControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__TransferControl = {"_p_mvIMPACT__acquire__GenICam__TransferControl", "mvIMPACT::acquire::GenICam::TransferControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__TransportLayerControl = {"_p_mvIMPACT__acquire__GenICam__TransportLayerControl", "mvIMPACT::acquire::GenICam::TransportLayerControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__UserSetControl = {"_p_mvIMPACT__acquire__GenICam__UserSetControl", "mvIMPACT::acquire::GenICam::UserSetControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl = {"_p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl", "mvIMPACT::acquire::GenICam::mvAutoFeatureControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvCurrentControl = {"_p_mvIMPACT__acquire__GenICam__mvCurrentControl", "mvIMPACT::acquire::GenICam::mvCurrentControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl = {"_p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl", "mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvFFCControl = {"_p_mvIMPACT__acquire__GenICam__mvFFCControl", "mvIMPACT::acquire::GenICam::mvFFCControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvFrameAverageControl = {"_p_mvIMPACT__acquire__GenICam__mvFrameAverageControl", "mvIMPACT::acquire::GenICam::mvFrameAverageControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvHDRControl = {"_p_mvIMPACT__acquire__GenICam__mvHDRControl", "mvIMPACT::acquire::GenICam::mvHDRControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl = {"_p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl", "mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvLensControl = {"_p_mvIMPACT__acquire__GenICam__mvLensControl", "mvIMPACT::acquire::GenICam::mvLensControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvLogicGateControl = {"_p_mvIMPACT__acquire__GenICam__mvLogicGateControl", "mvIMPACT::acquire::GenICam::mvLogicGateControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl = {"_p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl", "mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__HDRControl = {"_p_mvIMPACT__acquire__HDRControl", "mvIMPACT::acquire::HDRControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__HDRKneePoint = {"_p_mvIMPACT__acquire__HDRKneePoint", "mvIMPACT::acquire::HDRKneePoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__I2CControl = {"_p_mvIMPACT__acquire__I2CControl", "mvIMPACT::acquire::I2CControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__IOSubSystem = {"_p_mvIMPACT__acquire__IOSubSystem", "mvIMPACT::acquire::IOSubSystem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__IOSubSystemBlueFOX = {"_p_mvIMPACT__acquire__IOSubSystemBlueFOX", "mvIMPACT::acquire::IOSubSystemBlueFOX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__IOSubSystemCommon = {"_p_mvIMPACT__acquire__IOSubSystemCommon", "mvIMPACT::acquire::IOSubSystemCommon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__IOSubSystemFrameGrabber = {"_p_mvIMPACT__acquire__IOSubSystemFrameGrabber", "mvIMPACT::acquire::IOSubSystemFrameGrabber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ImageBuffer = {"_p_mvIMPACT__acquire__ImageBuffer", "mvIMPACT::acquire::ImageBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ImageBufferDesc = {"_p_mvIMPACT__acquire__ImageBufferDesc", "mvIMPACT::acquire::ImageBufferDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ImageDestination = {"_p_mvIMPACT__acquire__ImageDestination", "mvIMPACT::acquire::ImageDestination *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ImageMemoryManager = {"_p_mvIMPACT__acquire__ImageMemoryManager", "mvIMPACT::acquire::ImageMemoryManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ImageProcessing = {"_p_mvIMPACT__acquire__ImageProcessing", "mvIMPACT::acquire::ImageProcessing *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ImageRequestControl = {"_p_mvIMPACT__acquire__ImageRequestControl", "mvIMPACT::acquire::ImageRequestControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__ImpactAcquireException = {"_p_mvIMPACT__acquire__ImpactAcquireException", "mvIMPACT::acquire::ImpactAcquireException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__Info = {"_p_mvIMPACT__acquire__Info", "mvIMPACT::acquire::Info *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__InfoBlueCOUGAR = {"_p_mvIMPACT__acquire__InfoBlueCOUGAR", "mvIMPACT::acquire::InfoBlueCOUGAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__InfoBlueDevice = {"_p_mvIMPACT__acquire__InfoBlueDevice", "mvIMPACT::acquire::InfoBlueDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__InfoBlueFOX = {"_p_mvIMPACT__acquire__InfoBlueFOX", "mvIMPACT::acquire::InfoBlueFOX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__LUTParameters = {"_p_mvIMPACT__acquire__LUTParameters", "mvIMPACT::acquire::LUTParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__Method = {"_p_mvIMPACT__acquire__Method", "mvIMPACT::acquire::Method *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__MirrorParameters = {"_p_mvIMPACT__acquire__MirrorParameters", "mvIMPACT::acquire::MirrorParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__MotorFocusControl = {"_p_mvIMPACT__acquire__MotorFocusControl", "mvIMPACT::acquire::MotorFocusControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice = {"_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice", "mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber = {"_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber", "mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__Property = {"_p_mvIMPACT__acquire__Property", "mvIMPACT::acquire::Property *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__PropertyPtr = {"_p_mvIMPACT__acquire__PropertyPtr", "mvIMPACT::acquire::PropertyPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__PropertyS = {"_p_mvIMPACT__acquire__PropertyS", "mvIMPACT::acquire::PropertyS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__PulseStartConfiguration = {"_p_mvIMPACT__acquire__PulseStartConfiguration", "mvIMPACT::acquire::PulseStartConfiguration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__RTCtrProgram = {"_p_mvIMPACT__acquire__RTCtrProgram", "mvIMPACT::acquire::RTCtrProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__RTCtrProgramStep = {"_p_mvIMPACT__acquire__RTCtrProgramStep", "mvIMPACT::acquire::RTCtrProgramStep *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__Request = {"_p_mvIMPACT__acquire__Request", "mvIMPACT::acquire::Request *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__RequestFactory = {"_p_mvIMPACT__acquire__RequestFactory", "mvIMPACT::acquire::RequestFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__RequestInfoConfiguration = {"_p_mvIMPACT__acquire__RequestInfoConfiguration", "mvIMPACT::acquire::RequestInfoConfiguration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__SettingsBlueFOX = {"_p_mvIMPACT__acquire__SettingsBlueFOX", "mvIMPACT::acquire::SettingsBlueFOX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__SettingsFrameGrabber = {"_p_mvIMPACT__acquire__SettingsFrameGrabber", "mvIMPACT::acquire::SettingsFrameGrabber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__Statistics = {"_p_mvIMPACT__acquire__Statistics", "mvIMPACT::acquire::Statistics *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__SyncOutput = {"_p_mvIMPACT__acquire__SyncOutput", "mvIMPACT::acquire::SyncOutput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__SystemBlueFOX = {"_p_mvIMPACT__acquire__SystemBlueFOX", "mvIMPACT::acquire::SystemBlueFOX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__SystemSettings = {"_p_mvIMPACT__acquire__SystemSettings", "mvIMPACT::acquire::SystemSettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__SystemV4L2 = {"_p_mvIMPACT__acquire__SystemV4L2", "mvIMPACT::acquire::SystemV4L2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TriggerControl = {"_p_mvIMPACT__acquire__TriggerControl", "mvIMPACT::acquire::TriggerControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__UserData = {"_p_mvIMPACT__acquire__UserData", "mvIMPACT::acquire::UserData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__UserDataEntry = {"_p_mvIMPACT__acquire__UserDataEntry", "mvIMPACT::acquire::UserDataEntry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__WhiteBalanceSettings = {"_p_mvIMPACT__acquire__WhiteBalanceSettings", "mvIMPACT::acquire::WhiteBalanceSettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__WhiteBalancer = {"_p_mvIMPACT__acquire__WhiteBalancer", "mvIMPACT::acquire::WhiteBalancer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__labs__VideoStream = {"_p_mvIMPACT__acquire__labs__VideoStream", "mvIMPACT::acquire::labs::VideoStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__labs__VideoStreamPauseScope = {"_p_mvIMPACT__acquire__labs__VideoStreamPauseScope", "mvIMPACT::acquire::labs::VideoStreamPauseScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_second_type = {"_p_second_type", "second_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t_t = {"_p_std__mapT_std__string_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t_t", "std::map< std::string,mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour > *|std::map< std::string,mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_double_t = {"_p_std__pairT_std__string_double_t", "std::pair< std::string,double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_int_t = {"_p_std__pairT_std__string_int_t", "std::pair< std::string,int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_long_t = {"_p_std__pairT_std__string_long_t", "std::pair< std::string,long > *|std::pair< std::string,mvIMPACT::acquire::int64_type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t", "std::pair< std::string,enum mvIMPACT::acquire::TAcquisitionField > *|std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TAcquisitionMode > *|std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t", "std::pair< std::string,enum mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *|std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TAoiMode > *|std::pair< std::string,mvIMPACT::acquire::TAoiMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t", "std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > *|std::pair< std::string,enum mvIMPACT::acquire::TAutoControlMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t", "std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > *|std::pair< std::string,enum mvIMPACT::acquire::TAutoControlSpeed > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t", "std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > *|std::pair< std::string,enum mvIMPACT::acquire::TAutoExposureControl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t", "std::pair< std::string,enum mvIMPACT::acquire::TAutoGainControl > *|std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t", "std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > *|std::pair< std::string,enum mvIMPACT::acquire::TAutoOffsetCalibration > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TBayerConversionMode > *|std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t", "std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > *|std::pair< std::string,enum mvIMPACT::acquire::TBayerMosaicParity > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t", "std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > *|std::pair< std::string,enum mvIMPACT::acquire::TBayerWhiteBalanceResult > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t", "std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *|std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXFooterMode > *|std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t", "std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *|std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t", "std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *|std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t", "std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXSensorTiming > *|std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t", "std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXTransferSize > *|std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t", "std::pair< std::string,mvIMPACT::acquire::TBoolean > *|std::pair< std::string,enum mvIMPACT::acquire::TBoolean > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t", "std::pair< std::string,enum mvIMPACT::acquire::TBufferPartDataType > *|std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraAoiMode > *|std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraBinningMode > *|std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraDataFormat > *|std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraExposeMode > *|std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraExternalSyncEdge > *|std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraExternalSyncOutput > *|std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t", "std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > *|std::pair< std::string,enum mvIMPACT::acquire::TCameraFlashMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t", "std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > *|std::pair< std::string,enum mvIMPACT::acquire::TCameraFlashType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraHDRMode > *|std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraInterlacedType > *|std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraLinkDataValidMode > *|std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraOutput > *|std::pair< std::string,mvIMPACT::acquire::TCameraOutput > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraPixelClock > *|std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraScanMode > *|std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraSerialPortBaudRate > *|std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TCameraShutterMode > *|std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t", "std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > *|std::pair< std::string,enum mvIMPACT::acquire::TCameraTapsXGeometry > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t", "std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > *|std::pair< std::string,enum mvIMPACT::acquire::TCameraTapsYGeometry > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t", "std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > *|std::pair< std::string,enum mvIMPACT::acquire::TCameraTestMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t", "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > *|std::pair< std::string,enum mvIMPACT::acquire::TCameraTriggerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t", "std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > *|std::pair< std::string,enum mvIMPACT::acquire::TCameraTriggerSource > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t", "std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > *|std::pair< std::string,enum mvIMPACT::acquire::TChannelSplitMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t", "std::pair< std::string,mvIMPACT::acquire::TClampMode > *|std::pair< std::string,enum mvIMPACT::acquire::TClampMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TColorProcessingMode > *|std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *|std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *|std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t", "std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > *|std::pair< std::string,enum mvIMPACT::acquire::TDarkCurrentFilterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TDefectivePixelsFilterMode > *|std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceAccessMode > *|std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceAdvancedOptions > *|std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceCapability > *|std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceClass > *|std::pair< std::string,mvIMPACT::acquire::TDeviceClass > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceDigitalOutputMode > *|std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceImageTrigger > *|std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceInterfaceLayout > *|std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceLoadSettings > *|std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TDevicePowerMode > *|std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceScanRateMode > *|std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *|std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceState > *|std::pair< std::string,mvIMPACT::acquire::TDeviceState > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TDeviceSyncOutMode > *|std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t", "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > *|std::pair< std::string,enum mvIMPACT::acquire::TDeviceTriggerInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t", "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > *|std::pair< std::string,enum mvIMPACT::acquire::TDeviceTriggerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t", "std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > *|std::pair< std::string,enum mvIMPACT::acquire::TDeviceTriggerOverlap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t", "std::pair< std::string,mvIMPACT::acquire::TDigIOState > *|std::pair< std::string,enum mvIMPACT::acquire::TDigIOState > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t", "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > *|std::pair< std::string,enum mvIMPACT::acquire::TDigitalIOMeasurementMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t", "std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > *|std::pair< std::string,enum mvIMPACT::acquire::TDigitalIOMeasurementSource > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t", "std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > *|std::pair< std::string,enum mvIMPACT::acquire::TDigitalOutputControlMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t", "std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > *|std::pair< std::string,enum mvIMPACT::acquire::TDigitalSignal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TFieldGateMode > *|std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t", "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *|std::pair< std::string,enum mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t", "std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > *|std::pair< std::string,enum mvIMPACT::acquire::TFlatFieldFilterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t", "std::pair< std::string,enum mvIMPACT::acquire::THWUpdateResult > *|std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t", "std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > *|std::pair< std::string,enum mvIMPACT::acquire::TI2COperationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t", "std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > *|std::pair< std::string,enum mvIMPACT::acquire::TI2COperationStatus > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t", "std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *|std::pair< std::string,enum mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t", "std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > *|std::pair< std::string,enum mvIMPACT::acquire::TImageBufferPixelFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t", "std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > *|std::pair< std::string,enum mvIMPACT::acquire::TImageDestinationPixelFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t", "std::pair< std::string,enum mvIMPACT::acquire::TImageProcessingFilter > *|std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TImageProcessingMode > *|std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t", "std::pair< std::string,enum mvIMPACT::acquire::TImageProcessingOptimization > *|std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t", "std::pair< std::string,enum mvIMPACT::acquire::TImageProcessingResult > *|std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t", "std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > *|std::pair< std::string,enum mvIMPACT::acquire::TImageRequestControlMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t", "std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > *|std::pair< std::string,enum mvIMPACT::acquire::TInfoSensorColorMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t", "std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > *|std::pair< std::string,enum mvIMPACT::acquire::TInfoSensorType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t", "std::pair< std::string,enum mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *|std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TInterlacedMode > *|std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TLUTGammaMode > *|std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t", "std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > *|std::pair< std::string,enum mvIMPACT::acquire::TLUTImplementation > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TLUTInterpolationMode > *|std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t", "std::pair< std::string,enum mvIMPACT::acquire::TLUTMapping > *|std::pair< std::string,mvIMPACT::acquire::TLUTMapping > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t", "std::pair< std::string,mvIMPACT::acquire::TLUTMode > *|std::pair< std::string,enum mvIMPACT::acquire::TLUTMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t", "std::pair< std::string,mvIMPACT::acquire::TLineCounter > *|std::pair< std::string,enum mvIMPACT::acquire::TLineCounter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t", "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > *|std::pair< std::string,enum mvIMPACT::acquire::TMemoryManagerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t", "std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > *|std::pair< std::string,enum mvIMPACT::acquire::TMemoryManagerPoolMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TMirrorMode > *|std::pair< std::string,mvIMPACT::acquire::TMirrorMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TMirrorOperationMode > *|std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t", "std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > *|std::pair< std::string,enum mvIMPACT::acquire::TOnBoardMemoryMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t", "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *|std::pair< std::string,enum mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t", "std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > *|std::pair< std::string,enum mvIMPACT::acquire::TPolarizedDataExtractionMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t", "std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > *|std::pair< std::string,enum mvIMPACT::acquire::TPulseStartTrigger > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t", "std::pair< std::string,enum mvIMPACT::acquire::TRTCtrlModes > *|std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t", "std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > *|std::pair< std::string,enum mvIMPACT::acquire::TRTProgOpCodes > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t", "std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > *|std::pair< std::string,enum mvIMPACT::acquire::TRequestImageMemoryMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t", "std::pair< std::string,mvIMPACT::acquire::TRequestResult > *|std::pair< std::string,enum mvIMPACT::acquire::TRequestResult > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t", "std::pair< std::string,mvIMPACT::acquire::TRequestState > *|std::pair< std::string,enum mvIMPACT::acquire::TRequestState > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t", "std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > *|std::pair< std::string,enum mvIMPACT::acquire::TScalerInterpolationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TScalerMode > *|std::pair< std::string,mvIMPACT::acquire::TScalerMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t", "std::pair< std::string,enum mvIMPACT::acquire::TScanClock > *|std::pair< std::string,mvIMPACT::acquire::TScanClock > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t", "std::pair< std::string,enum mvIMPACT::acquire::TScanStandard > *|std::pair< std::string,mvIMPACT::acquire::TScanStandard > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t", "std::pair< std::string,enum mvIMPACT::acquire::TTriggerMoment > *|std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t", "std::pair< std::string,enum mvIMPACT::acquire::TUserDataAccessRight > *|std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t", "std::pair< std::string,enum mvIMPACT::acquire::TUserDataReconnectBehaviour > *|std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t", "std::pair< std::string,mvIMPACT::acquire::TVideoStandard > *|std::pair< std::string,enum mvIMPACT::acquire::TVideoStandard > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t", "std::pair< std::string,enum mvIMPACT::acquire::TVirtualDeviceImageType > *|std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t", "std::pair< std::string,enum mvIMPACT::acquire::TVirtualDeviceTestMode > *|std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t", "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *|std::pair< std::string,enum mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t = {"_p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t", "std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > *|std::pair< std::string,enum mvIMPACT::acquire::TWhiteBalanceParameter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__runtime_error = {"_p_std__runtime_error", "std::runtime_error *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_mvIMPACT__acquire__Component_std__allocatorT_mvIMPACT__acquire__Component_t_t = {"_p_std__vectorT_mvIMPACT__acquire__Component_std__allocatorT_mvIMPACT__acquire__Component_t_t", "std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_std__allocatorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_t_t = {"_p_std__vectorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_std__allocatorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_t_t", "std::vector< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration,std::allocator< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_std__allocatorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_std__allocatorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDigitalSignal >,std::allocator< std::pair< std::string,enum mvIMPACT::acquire::TDigitalSignal > > > *|mvIMPACT::acquire::TDigitalSignalTranslationDict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_void_p_std__allocatorT_void_p_t_t = {"_p_std__vectorT_void_p_std__allocatorT_void_p_t_t", "std::vector< void *,std::allocator< void * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_uint16_t = {"_p_uint16_t", "mvIMPACT::acquire::GenICam::uint16_type *|uint16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "mvIMPACT::acquire::GenICam::uint32_type *|uint32_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "uint64_type *|unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_char,
  &_swigt__p_first_type,
  &_swigt__p_int,
  &_swigt__p_int16_t,
  &_swigt__p_int32_t,
  &_swigt__p_long,
  &_swigt__p_mvIMPACT__acquire__AutoControlParameters,
  &_swigt__p_mvIMPACT__acquire__BasicDeviceSettings,
  &_swigt__p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI,
  &_swigt__p_mvIMPACT__acquire__BufferPart,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionBase,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionCameraLink,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionDigital,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase2,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionManager,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionNonStandard,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionSDI,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionStandard,
  &_swigt__p_mvIMPACT__acquire__CameraDescriptionStandardBase,
  &_swigt__p_mvIMPACT__acquire__CameraSettingsBase,
  &_swigt__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR,
  &_swigt__p_mvIMPACT__acquire__CameraSettingsBlueDevice,
  &_swigt__p_mvIMPACT__acquire__CameraSettingsBlueFOX,
  &_swigt__p_mvIMPACT__acquire__CameraSettingsFrameGrabber,
  &_swigt__p_mvIMPACT__acquire__CameraSettingsV4L2Device,
  &_swigt__p_mvIMPACT__acquire__CameraSettingsVirtualDevice,
  &_swigt__p_mvIMPACT__acquire__ChannelData,
  &_swigt__p_mvIMPACT__acquire__Component,
  &_swigt__p_mvIMPACT__acquire__ComponentAccess,
  &_swigt__p_mvIMPACT__acquire__ComponentCallback,
  &_swigt__p_mvIMPACT__acquire__ComponentCollection,
  &_swigt__p_mvIMPACT__acquire__ComponentList,
  &_swigt__p_mvIMPACT__acquire__ComponentLocator,
  &_swigt__p_mvIMPACT__acquire__ComponentLocatorBase,
  &_swigt__p_mvIMPACT__acquire__Connector,
  &_swigt__p_mvIMPACT__acquire__Device,
  &_swigt__p_mvIMPACT__acquire__DeviceComponentLocator,
  &_swigt__p_mvIMPACT__acquire__DeviceManager,
  &_swigt__p_mvIMPACT__acquire__DigitalIOMeasurementControl,
  &_swigt__p_mvIMPACT__acquire__DigitalInput,
  &_swigt__p_mvIMPACT__acquire__DigitalOutput,
  &_swigt__p_mvIMPACT__acquire__ECantAccessData,
  &_swigt__p_mvIMPACT__acquire__ECantAllocateNewList,
  &_swigt__p_mvIMPACT__acquire__ECantRegisterComponent,
  &_swigt__p_mvIMPACT__acquire__ECantSerializeData,
  &_swigt__p_mvIMPACT__acquire__EComponent,
  &_swigt__p_mvIMPACT__acquire__EComponentIDInvalid,
  &_swigt__p_mvIMPACT__acquire__EComponentNotFound,
  &_swigt__p_mvIMPACT__acquire__EDeviceManager,
  &_swigt__p_mvIMPACT__acquire__EImplementationMissing,
  &_swigt__p_mvIMPACT__acquire__EIncompatibleComponents,
  &_swigt__p_mvIMPACT__acquire__EInputBufferTooSmall,
  &_swigt__p_mvIMPACT__acquire__EInvalidFileContent,
  &_swigt__p_mvIMPACT__acquire__EInvalidInputParameter,
  &_swigt__p_mvIMPACT__acquire__EInvalidListID,
  &_swigt__p_mvIMPACT__acquire__EInvalidParameterList,
  &_swigt__p_mvIMPACT__acquire__EInvalidValue,
  &_swigt__p_mvIMPACT__acquire__EInvalidValueType,
  &_swigt__p_mvIMPACT__acquire__EListEntryOccupied,
  &_swigt__p_mvIMPACT__acquire__EMethod,
  &_swigt__p_mvIMPACT__acquire__EMethodPtrInvalid,
  &_swigt__p_mvIMPACT__acquire__ENoModifySizeRights,
  &_swigt__p_mvIMPACT__acquire__ENoReadRights,
  &_swigt__p_mvIMPACT__acquire__ENoWriteRights,
  &_swigt__p_mvIMPACT__acquire__ENotAList,
  &_swigt__p_mvIMPACT__acquire__ENotAMethod,
  &_swigt__p_mvIMPACT__acquire__ENotAProperty,
  &_swigt__p_mvIMPACT__acquire__EProperty,
  &_swigt__p_mvIMPACT__acquire__EPropertyHandling,
  &_swigt__p_mvIMPACT__acquire__EPropertyList,
  &_swigt__p_mvIMPACT__acquire__ESizeMismatch,
  &_swigt__p_mvIMPACT__acquire__ETranslationTableCorrupted,
  &_swigt__p_mvIMPACT__acquire__ETranslationTableNotDefined,
  &_swigt__p_mvIMPACT__acquire__EUnsupportedOperation,
  &_swigt__p_mvIMPACT__acquire__EUnsupportedParameter,
  &_swigt__p_mvIMPACT__acquire__EValIDOutOfBounds,
  &_swigt__p_mvIMPACT__acquire__EValTooLarge,
  &_swigt__p_mvIMPACT__acquire__EValTooSmall,
  &_swigt__p_mvIMPACT__acquire__EValidationFailed,
  &_swigt__p_mvIMPACT__acquire__EWrongParamCount,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyFT_double_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_long_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_int_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAutoNegotiatePacketSizeMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t,
  &_swigt__p_mvIMPACT__acquire__ExceptionFactory,
  &_swigt__p_mvIMPACT__acquire__FirmwareUpdater,
  &_swigt__p_mvIMPACT__acquire__FullSettingsBase,
  &_swigt__p_mvIMPACT__acquire__FunctionInterface,
  &_swigt__p_mvIMPACT__acquire__GainOffsetKneeChannelParameters,
  &_swigt__p_mvIMPACT__acquire__GenICam__AcquisitionControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__ActionControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__AnalogControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__ChunkDataControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__ColorTransformationControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__CounterAndTimerControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__CustomCommandGenerator,
  &_swigt__p_mvIMPACT__acquire__GenICam__DataStreamModule,
  &_swigt__p_mvIMPACT__acquire__GenICam__DepthControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__DeviceControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__DeviceModule,
  &_swigt__p_mvIMPACT__acquire__GenICam__DigitalIOControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__EncoderControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__EventControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__FileAccessControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator,
  &_swigt__p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration,
  &_swigt__p_mvIMPACT__acquire__GenICam__ImageFormatControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__InterfaceModule,
  &_swigt__p_mvIMPACT__acquire__GenICam__LUTControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__LightControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__LogicBlockControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__OpticControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__Scan3dControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__SequencerControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__SoftwareSignalControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__SourceControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__SystemModule,
  &_swigt__p_mvIMPACT__acquire__GenICam__TestControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__TransferControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__TransportLayerControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__UserSetControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvCurrentControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvFFCControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvFrameAverageControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvHDRControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvLensControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvLogicGateControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl,
  &_swigt__p_mvIMPACT__acquire__HDRControl,
  &_swigt__p_mvIMPACT__acquire__HDRKneePoint,
  &_swigt__p_mvIMPACT__acquire__I2CControl,
  &_swigt__p_mvIMPACT__acquire__IOSubSystem,
  &_swigt__p_mvIMPACT__acquire__IOSubSystemBlueFOX,
  &_swigt__p_mvIMPACT__acquire__IOSubSystemCommon,
  &_swigt__p_mvIMPACT__acquire__IOSubSystemFrameGrabber,
  &_swigt__p_mvIMPACT__acquire__ImageBuffer,
  &_swigt__p_mvIMPACT__acquire__ImageBufferDesc,
  &_swigt__p_mvIMPACT__acquire__ImageDestination,
  &_swigt__p_mvIMPACT__acquire__ImageMemoryManager,
  &_swigt__p_mvIMPACT__acquire__ImageProcessing,
  &_swigt__p_mvIMPACT__acquire__ImageRequestControl,
  &_swigt__p_mvIMPACT__acquire__ImpactAcquireException,
  &_swigt__p_mvIMPACT__acquire__Info,
  &_swigt__p_mvIMPACT__acquire__InfoBlueCOUGAR,
  &_swigt__p_mvIMPACT__acquire__InfoBlueDevice,
  &_swigt__p_mvIMPACT__acquire__InfoBlueFOX,
  &_swigt__p_mvIMPACT__acquire__LUTParameters,
  &_swigt__p_mvIMPACT__acquire__Method,
  &_swigt__p_mvIMPACT__acquire__MirrorParameters,
  &_swigt__p_mvIMPACT__acquire__MotorFocusControl,
  &_swigt__p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice,
  &_swigt__p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber,
  &_swigt__p_mvIMPACT__acquire__Property,
  &_swigt__p_mvIMPACT__acquire__PropertyPtr,
  &_swigt__p_mvIMPACT__acquire__PropertyS,
  &_swigt__p_mvIMPACT__acquire__PulseStartConfiguration,
  &_swigt__p_mvIMPACT__acquire__RTCtrProgram,
  &_swigt__p_mvIMPACT__acquire__RTCtrProgramStep,
  &_swigt__p_mvIMPACT__acquire__Request,
  &_swigt__p_mvIMPACT__acquire__RequestFactory,
  &_swigt__p_mvIMPACT__acquire__RequestInfoConfiguration,
  &_swigt__p_mvIMPACT__acquire__SettingsBlueFOX,
  &_swigt__p_mvIMPACT__acquire__SettingsFrameGrabber,
  &_swigt__p_mvIMPACT__acquire__Statistics,
  &_swigt__p_mvIMPACT__acquire__SyncOutput,
  &_swigt__p_mvIMPACT__acquire__SystemBlueFOX,
  &_swigt__p_mvIMPACT__acquire__SystemSettings,
  &_swigt__p_mvIMPACT__acquire__SystemV4L2,
  &_swigt__p_mvIMPACT__acquire__TriggerControl,
  &_swigt__p_mvIMPACT__acquire__UserData,
  &_swigt__p_mvIMPACT__acquire__UserDataEntry,
  &_swigt__p_mvIMPACT__acquire__WhiteBalanceSettings,
  &_swigt__p_mvIMPACT__acquire__WhiteBalancer,
  &_swigt__p_mvIMPACT__acquire__labs__VideoStream,
  &_swigt__p_mvIMPACT__acquire__labs__VideoStreamPauseScope,
  &_swigt__p_second_type,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__mapT_std__string_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t_t,
  &_swigt__p_std__pairT_std__string_double_t,
  &_swigt__p_std__pairT_std__string_int_t,
  &_swigt__p_std__pairT_std__string_long_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t,
  &_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t,
  &_swigt__p_std__runtime_error,
  &_swigt__p_std__string,
  &_swigt__p_std__vectorT_mvIMPACT__acquire__Component_std__allocatorT_mvIMPACT__acquire__Component_t_t,
  &_swigt__p_std__vectorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_std__allocatorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_std__allocatorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t_t,
  &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  &_swigt__p_std__vectorT_void_p_std__allocatorT_void_p_t_t,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_uint16_t,
  &_swigt__p_uint32_t,
  &_swigt__p_unsigned_long,
  &_swigt__p_void,
};

static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_first_type[] = {  {&_swigt__p_first_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int16_t[] = {  {&_swigt__p_int16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int32_t[] = {  {&_swigt__p_int32_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__AutoControlParameters[] = {  {&_swigt__p_mvIMPACT__acquire__AutoControlParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__BasicDeviceSettings[] = {  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBase, _p_mvIMPACT__acquire__CameraSettingsBaseTo_p_mvIMPACT__acquire__BasicDeviceSettings, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, _p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__BasicDeviceSettings, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueFOX, _p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__BasicDeviceSettings, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsFrameGrabber, _p_mvIMPACT__acquire__CameraSettingsFrameGrabberTo_p_mvIMPACT__acquire__BasicDeviceSettings, 0, 0},  {&_swigt__p_mvIMPACT__acquire__BasicDeviceSettings, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsVirtualDevice, _p_mvIMPACT__acquire__CameraSettingsVirtualDeviceTo_p_mvIMPACT__acquire__BasicDeviceSettings, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsV4L2Device, _p_mvIMPACT__acquire__CameraSettingsV4L2DeviceTo_p_mvIMPACT__acquire__BasicDeviceSettings, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueDevice, _p_mvIMPACT__acquire__CameraSettingsBlueDeviceTo_p_mvIMPACT__acquire__BasicDeviceSettings, 0, 0},  {&_swigt__p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, _p_mvIMPACT__acquire__BasicDeviceSettingsWithAOITo_p_mvIMPACT__acquire__BasicDeviceSettings, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI[] = {  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBase, _p_mvIMPACT__acquire__CameraSettingsBaseTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, _p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueFOX, _p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsFrameGrabber, _p_mvIMPACT__acquire__CameraSettingsFrameGrabberTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsVirtualDevice, _p_mvIMPACT__acquire__CameraSettingsVirtualDeviceTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsV4L2Device, _p_mvIMPACT__acquire__CameraSettingsV4L2DeviceTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0, 0},  {&_swigt__p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueDevice, _p_mvIMPACT__acquire__CameraSettingsBlueDeviceTo_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__BufferPart[] = {  {&_swigt__p_mvIMPACT__acquire__BufferPart, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionBase[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionBase, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase, _p_mvIMPACT__acquire__CameraDescriptionDigitalBaseTo_p_mvIMPACT__acquire__CameraDescriptionBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, _p_mvIMPACT__acquire__CameraDescriptionDigitalBase2To_p_mvIMPACT__acquire__CameraDescriptionBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionCameraLink, _p_mvIMPACT__acquire__CameraDescriptionCameraLinkTo_p_mvIMPACT__acquire__CameraDescriptionBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigital, _p_mvIMPACT__acquire__CameraDescriptionDigitalTo_p_mvIMPACT__acquire__CameraDescriptionBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionStandardBase, _p_mvIMPACT__acquire__CameraDescriptionStandardBaseTo_p_mvIMPACT__acquire__CameraDescriptionBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionStandard, _p_mvIMPACT__acquire__CameraDescriptionStandardTo_p_mvIMPACT__acquire__CameraDescriptionBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionNonStandard, _p_mvIMPACT__acquire__CameraDescriptionNonStandardTo_p_mvIMPACT__acquire__CameraDescriptionBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionSDI, _p_mvIMPACT__acquire__CameraDescriptionSDITo_p_mvIMPACT__acquire__CameraDescriptionBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionCameraLink[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionCameraLink, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionDigital[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigital, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionDigitalBase[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, _p_mvIMPACT__acquire__CameraDescriptionDigitalBase2To_p_mvIMPACT__acquire__CameraDescriptionDigitalBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionCameraLink, _p_mvIMPACT__acquire__CameraDescriptionCameraLinkTo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigital, _p_mvIMPACT__acquire__CameraDescriptionDigitalTo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionSDI, _p_mvIMPACT__acquire__CameraDescriptionSDITo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionDigitalBase2[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionCameraLink, _p_mvIMPACT__acquire__CameraDescriptionCameraLinkTo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigital, _p_mvIMPACT__acquire__CameraDescriptionDigitalTo_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionManager[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionNonStandard[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionNonStandard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionSDI[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionSDI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionStandard[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionStandard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraDescriptionStandardBase[] = {  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionStandardBase, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionStandard, _p_mvIMPACT__acquire__CameraDescriptionStandardTo_p_mvIMPACT__acquire__CameraDescriptionStandardBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionNonStandard, _p_mvIMPACT__acquire__CameraDescriptionNonStandardTo_p_mvIMPACT__acquire__CameraDescriptionStandardBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraSettingsBase[] = {  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBase, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, _p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__CameraSettingsBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueFOX, _p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__CameraSettingsBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsFrameGrabber, _p_mvIMPACT__acquire__CameraSettingsFrameGrabberTo_p_mvIMPACT__acquire__CameraSettingsBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsVirtualDevice, _p_mvIMPACT__acquire__CameraSettingsVirtualDeviceTo_p_mvIMPACT__acquire__CameraSettingsBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueDevice, _p_mvIMPACT__acquire__CameraSettingsBlueDeviceTo_p_mvIMPACT__acquire__CameraSettingsBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR[] = {  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraSettingsBlueDevice[] = {  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, _p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueFOX, _p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraSettingsBlueFOX[] = {  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueFOX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraSettingsFrameGrabber[] = {  {&_swigt__p_mvIMPACT__acquire__CameraSettingsFrameGrabber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraSettingsV4L2Device[] = {  {&_swigt__p_mvIMPACT__acquire__CameraSettingsV4L2Device, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__CameraSettingsVirtualDevice[] = {  {&_swigt__p_mvIMPACT__acquire__CameraSettingsVirtualDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ChannelData[] = {  {&_swigt__p_mvIMPACT__acquire__ChannelData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__Component[] = {  {&_swigt__p_mvIMPACT__acquire__PropertyPtr, _p_mvIMPACT__acquire__PropertyPtrTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, _p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, _p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Component, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Property, _p_mvIMPACT__acquire__PropertyTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyFT_double_t, _p_mvIMPACT__acquire__EnumPropertyFT_double_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_long_t, _p_mvIMPACT__acquire__EnumPropertyI64T_long_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_int_t, _p_mvIMPACT__acquire__EnumPropertyIT_int_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Method, _p_mvIMPACT__acquire__MethodTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__PropertyS, _p_mvIMPACT__acquire__PropertySTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ComponentList, _p_mvIMPACT__acquire__ComponentListTo_p_mvIMPACT__acquire__Component, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ComponentAccess[] = {  {&_swigt__p_mvIMPACT__acquire__PropertyPtr, _p_mvIMPACT__acquire__PropertyPtrTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ComponentLocatorBase, _p_mvIMPACT__acquire__ComponentLocatorBaseTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, _p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, _p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Component, _p_mvIMPACT__acquire__ComponentTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Property, _p_mvIMPACT__acquire__PropertyTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyFT_double_t, _p_mvIMPACT__acquire__EnumPropertyFT_double_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__DeviceComponentLocator, _p_mvIMPACT__acquire__DeviceComponentLocatorTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ComponentLocator, _p_mvIMPACT__acquire__ComponentLocatorTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_long_t, _p_mvIMPACT__acquire__EnumPropertyI64T_long_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ComponentAccess, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_int_t, _p_mvIMPACT__acquire__EnumPropertyIT_int_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Method, _p_mvIMPACT__acquire__MethodTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__PropertyS, _p_mvIMPACT__acquire__PropertySTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ComponentList, _p_mvIMPACT__acquire__ComponentListTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ComponentCallback[] = {  {&_swigt__p_mvIMPACT__acquire__ComponentCallback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ComponentCollection[] = {  {&_swigt__p_mvIMPACT__acquire__BasicDeviceSettings, _p_mvIMPACT__acquire__BasicDeviceSettingsTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__WhiteBalanceSettings, _p_mvIMPACT__acquire__WhiteBalanceSettingsTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__SystemSettings, _p_mvIMPACT__acquire__SystemSettingsTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ImageDestination, _p_mvIMPACT__acquire__ImageDestinationTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Info, _p_mvIMPACT__acquire__InfoTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__MirrorParameters, _p_mvIMPACT__acquire__MirrorParametersTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__LUTParameters, _p_mvIMPACT__acquire__LUTParametersTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__AutoControlParameters, _p_mvIMPACT__acquire__AutoControlParametersTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__InfoBlueDevice, _p_mvIMPACT__acquire__InfoBlueDeviceTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueDevice, _p_mvIMPACT__acquire__CameraSettingsBlueDeviceTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI, _p_mvIMPACT__acquire__BasicDeviceSettingsWithAOITo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, _p_mvIMPACT__acquire__GenICam__mvFrameAverageControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__PulseStartConfiguration, _p_mvIMPACT__acquire__PulseStartConfigurationTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__RequestInfoConfiguration, _p_mvIMPACT__acquire__RequestInfoConfigurationTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__I2CControl, _p_mvIMPACT__acquire__I2CControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__MotorFocusControl, _p_mvIMPACT__acquire__MotorFocusControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__DigitalIOMeasurementControl, _p_mvIMPACT__acquire__DigitalIOMeasurementControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__DepthControl, _p_mvIMPACT__acquire__GenICam__DepthControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__mvLogicGateControl, _p_mvIMPACT__acquire__GenICam__mvLogicGateControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__mvCurrentControl, _p_mvIMPACT__acquire__GenICam__mvCurrentControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__mvLensControl, _p_mvIMPACT__acquire__GenICam__mvLensControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__mvFFCControl, _p_mvIMPACT__acquire__GenICam__mvFFCControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__mvHDRControl, _p_mvIMPACT__acquire__GenICam__mvHDRControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__TriggerControl, _p_mvIMPACT__acquire__TriggerControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ImageRequestControl, _p_mvIMPACT__acquire__ImageRequestControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__HDRControl, _p_mvIMPACT__acquire__HDRControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, _p_mvIMPACT__acquire__GenICam__mvAutoFeatureControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__HDRKneePoint, _p_mvIMPACT__acquire__HDRKneePointTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionStandardBase, _p_mvIMPACT__acquire__CameraDescriptionStandardBaseTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ComponentCollection, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBase, _p_mvIMPACT__acquire__CameraSettingsBaseTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__RTCtrProgramStep, _p_mvIMPACT__acquire__RTCtrProgramStepTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionSDI, _p_mvIMPACT__acquire__CameraDescriptionSDITo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionCameraLink, _p_mvIMPACT__acquire__CameraDescriptionCameraLinkTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigital, _p_mvIMPACT__acquire__CameraDescriptionDigitalTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, _p_mvIMPACT__acquire__GenICam__GenTLProducerConfigurationTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Statistics, _p_mvIMPACT__acquire__StatisticsTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, _p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__InfoBlueCOUGAR, _p_mvIMPACT__acquire__InfoBlueCOUGARTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR, _p_mvIMPACT__acquire__CameraSettingsBlueCOUGARTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ImageProcessing, _p_mvIMPACT__acquire__ImageProcessingTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__BufferPart, _p_mvIMPACT__acquire__BufferPartTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__SystemModule, _p_mvIMPACT__acquire__GenICam__SystemModuleTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__InterfaceModule, _p_mvIMPACT__acquire__GenICam__InterfaceModuleTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__DeviceModule, _p_mvIMPACT__acquire__GenICam__DeviceModuleTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__DataStreamModule, _p_mvIMPACT__acquire__GenICam__DataStreamModuleTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, _p_mvIMPACT__acquire__GenICam__GenTLDriverConfiguratorTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, _p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControlTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsFrameGrabber, _p_mvIMPACT__acquire__CameraSettingsFrameGrabberTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__SyncOutput, _p_mvIMPACT__acquire__SyncOutputTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__SystemV4L2, _p_mvIMPACT__acquire__SystemV4L2To_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsVirtualDevice, _p_mvIMPACT__acquire__CameraSettingsVirtualDeviceTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsV4L2Device, _p_mvIMPACT__acquire__CameraSettingsV4L2DeviceTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__InfoBlueFOX, _p_mvIMPACT__acquire__InfoBlueFOXTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraSettingsBlueFOX, _p_mvIMPACT__acquire__CameraSettingsBlueFOXTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__SystemBlueFOX, _p_mvIMPACT__acquire__SystemBlueFOXTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase2, _p_mvIMPACT__acquire__CameraDescriptionDigitalBase2To_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__RTCtrProgram, _p_mvIMPACT__acquire__RTCtrProgramTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionDigitalBase, _p_mvIMPACT__acquire__CameraDescriptionDigitalBaseTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionStandard, _p_mvIMPACT__acquire__CameraDescriptionStandardTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionNonStandard, _p_mvIMPACT__acquire__CameraDescriptionNonStandardTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__GainOffsetKneeChannelParameters, _p_mvIMPACT__acquire__GainOffsetKneeChannelParametersTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Connector, _p_mvIMPACT__acquire__ConnectorTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ImageMemoryManager, _p_mvIMPACT__acquire__ImageMemoryManagerTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},  {&_swigt__p_mvIMPACT__acquire__CameraDescriptionBase, _p_mvIMPACT__acquire__CameraDescriptionBaseTo_p_mvIMPACT__acquire__ComponentCollection, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ComponentList[] = {  {&_swigt__p_mvIMPACT__acquire__ComponentList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ComponentLocator[] = {  {&_swigt__p_mvIMPACT__acquire__ComponentLocator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ComponentLocatorBase[] = {  {&_swigt__p_mvIMPACT__acquire__ComponentLocator, _p_mvIMPACT__acquire__ComponentLocatorTo_p_mvIMPACT__acquire__ComponentLocatorBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__DeviceComponentLocator, _p_mvIMPACT__acquire__DeviceComponentLocatorTo_p_mvIMPACT__acquire__ComponentLocatorBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ComponentLocatorBase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__Connector[] = {  {&_swigt__p_mvIMPACT__acquire__Connector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__Device[] = {  {&_swigt__p_mvIMPACT__acquire__Device, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__DeviceComponentLocator[] = {  {&_swigt__p_mvIMPACT__acquire__DeviceComponentLocator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__DeviceManager[] = {  {&_swigt__p_mvIMPACT__acquire__DeviceManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__DigitalIOMeasurementControl[] = {  {&_swigt__p_mvIMPACT__acquire__DigitalIOMeasurementControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__DigitalInput[] = {  {&_swigt__p_mvIMPACT__acquire__DigitalInput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__DigitalOutput[] = {  {&_swigt__p_mvIMPACT__acquire__DigitalOutput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ECantAccessData[] = {  {&_swigt__p_mvIMPACT__acquire__ECantAccessData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ECantAllocateNewList[] = {  {&_swigt__p_mvIMPACT__acquire__ECantAllocateNewList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ECantRegisterComponent[] = {  {&_swigt__p_mvIMPACT__acquire__ECantRegisterComponent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ECantSerializeData[] = {  {&_swigt__p_mvIMPACT__acquire__ECantSerializeData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EComponent[] = {  {&_swigt__p_mvIMPACT__acquire__EInvalidValueType, _p_mvIMPACT__acquire__EInvalidValueTypeTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentIDInvalid, _p_mvIMPACT__acquire__EComponentIDInvalidTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EMethodPtrInvalid, _p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValidationFailed, _p_mvIMPACT__acquire__EValidationFailedTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAMethod, _p_mvIMPACT__acquire__ENotAMethodTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EMethod, _p_mvIMPACT__acquire__EMethodTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoReadRights, _p_mvIMPACT__acquire__ENoReadRightsTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValTooSmall, _p_mvIMPACT__acquire__EValTooSmallTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EPropertyList, _p_mvIMPACT__acquire__EPropertyListTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantRegisterComponent, _p_mvIMPACT__acquire__ECantRegisterComponentTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponent, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValTooLarge, _p_mvIMPACT__acquire__EValTooLargeTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantAccessData, _p_mvIMPACT__acquire__ECantAccessDataTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidValue, _p_mvIMPACT__acquire__EInvalidValueTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentNotFound, _p_mvIMPACT__acquire__EComponentNotFoundTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EListEntryOccupied, _p_mvIMPACT__acquire__EListEntryOccupiedTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EIncompatibleComponents, _p_mvIMPACT__acquire__EIncompatibleComponentsTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValIDOutOfBounds, _p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableCorrupted, _p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EProperty, _p_mvIMPACT__acquire__EPropertyTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAProperty, _p_mvIMPACT__acquire__ENotAPropertyTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAList, _p_mvIMPACT__acquire__ENotAListTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidListID, _p_mvIMPACT__acquire__EInvalidListIDTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableNotDefined, _p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoModifySizeRights, _p_mvIMPACT__acquire__ENoModifySizeRightsTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoWriteRights, _p_mvIMPACT__acquire__ENoWriteRightsTo_p_mvIMPACT__acquire__EComponent, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidParameterList, _p_mvIMPACT__acquire__EInvalidParameterListTo_p_mvIMPACT__acquire__EComponent, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EComponentIDInvalid[] = {  {&_swigt__p_mvIMPACT__acquire__EComponentIDInvalid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EComponentNotFound[] = {  {&_swigt__p_mvIMPACT__acquire__EComponentNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EDeviceManager[] = {  {&_swigt__p_mvIMPACT__acquire__EDeviceManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EImplementationMissing[] = {  {&_swigt__p_mvIMPACT__acquire__EImplementationMissing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EIncompatibleComponents[] = {  {&_swigt__p_mvIMPACT__acquire__EIncompatibleComponents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EInputBufferTooSmall[] = {  {&_swigt__p_mvIMPACT__acquire__EInputBufferTooSmall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EInvalidFileContent[] = {  {&_swigt__p_mvIMPACT__acquire__EInvalidFileContent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EInvalidInputParameter[] = {  {&_swigt__p_mvIMPACT__acquire__EInvalidInputParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EInvalidListID[] = {  {&_swigt__p_mvIMPACT__acquire__EInvalidListID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EInvalidParameterList[] = {  {&_swigt__p_mvIMPACT__acquire__EInvalidParameterList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EInvalidValue[] = {  {&_swigt__p_mvIMPACT__acquire__EInvalidValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EInvalidValueType[] = {  {&_swigt__p_mvIMPACT__acquire__EInvalidValueType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EListEntryOccupied[] = {  {&_swigt__p_mvIMPACT__acquire__EListEntryOccupied, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EMethod[] = {  {&_swigt__p_mvIMPACT__acquire__EMethodPtrInvalid, _p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_mvIMPACT__acquire__EMethod, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EMethod, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidParameterList, _p_mvIMPACT__acquire__EInvalidParameterListTo_p_mvIMPACT__acquire__EMethod, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EMethodPtrInvalid[] = {  {&_swigt__p_mvIMPACT__acquire__EMethodPtrInvalid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ENoModifySizeRights[] = {  {&_swigt__p_mvIMPACT__acquire__ENoModifySizeRights, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ENoReadRights[] = {  {&_swigt__p_mvIMPACT__acquire__ENoReadRights, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ENoWriteRights[] = {  {&_swigt__p_mvIMPACT__acquire__ENoWriteRights, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ENotAList[] = {  {&_swigt__p_mvIMPACT__acquire__ENotAList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ENotAMethod[] = {  {&_swigt__p_mvIMPACT__acquire__ENotAMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ENotAProperty[] = {  {&_swigt__p_mvIMPACT__acquire__ENotAProperty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EProperty[] = {  {&_swigt__p_mvIMPACT__acquire__EProperty, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValidationFailed, _p_mvIMPACT__acquire__EValidationFailedTo_p_mvIMPACT__acquire__EProperty, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValTooSmall, _p_mvIMPACT__acquire__EValTooSmallTo_p_mvIMPACT__acquire__EProperty, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidValue, _p_mvIMPACT__acquire__EInvalidValueTo_p_mvIMPACT__acquire__EProperty, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableCorrupted, _p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_mvIMPACT__acquire__EProperty, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableNotDefined, _p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_mvIMPACT__acquire__EProperty, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValTooLarge, _p_mvIMPACT__acquire__EValTooLargeTo_p_mvIMPACT__acquire__EProperty, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValIDOutOfBounds, _p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_mvIMPACT__acquire__EProperty, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidValueType, _p_mvIMPACT__acquire__EInvalidValueTypeTo_p_mvIMPACT__acquire__EProperty, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EPropertyHandling[] = {  {&_swigt__p_mvIMPACT__acquire__EValTooLarge, _p_mvIMPACT__acquire__EValTooLargeTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EIncompatibleComponents, _p_mvIMPACT__acquire__EIncompatibleComponentsTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidValue, _p_mvIMPACT__acquire__EInvalidValueTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValidationFailed, _p_mvIMPACT__acquire__EValidationFailedTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EWrongParamCount, _p_mvIMPACT__acquire__EWrongParamCountTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoReadRights, _p_mvIMPACT__acquire__ENoReadRightsTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentNotFound, _p_mvIMPACT__acquire__EComponentNotFoundTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EUnsupportedOperation, _p_mvIMPACT__acquire__EUnsupportedOperationTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidValueType, _p_mvIMPACT__acquire__EInvalidValueTypeTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoWriteRights, _p_mvIMPACT__acquire__ENoWriteRightsTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoModifySizeRights, _p_mvIMPACT__acquire__ENoModifySizeRightsTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableCorrupted, _p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidParameterList, _p_mvIMPACT__acquire__EInvalidParameterListTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EMethod, _p_mvIMPACT__acquire__EMethodTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAMethod, _p_mvIMPACT__acquire__ENotAMethodTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantRegisterComponent, _p_mvIMPACT__acquire__ECantRegisterComponentTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponent, _p_mvIMPACT__acquire__EComponentTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAList, _p_mvIMPACT__acquire__ENotAListTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ESizeMismatch, _p_mvIMPACT__acquire__ESizeMismatchTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EListEntryOccupied, _p_mvIMPACT__acquire__EListEntryOccupiedTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantAccessData, _p_mvIMPACT__acquire__ECantAccessDataTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentIDInvalid, _p_mvIMPACT__acquire__EComponentIDInvalidTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EMethodPtrInvalid, _p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableNotDefined, _p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidInputParameter, _p_mvIMPACT__acquire__EInvalidInputParameterTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EUnsupportedParameter, _p_mvIMPACT__acquire__EUnsupportedParameterTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAProperty, _p_mvIMPACT__acquire__ENotAPropertyTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EProperty, _p_mvIMPACT__acquire__EPropertyTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValIDOutOfBounds, _p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EPropertyHandling, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInputBufferTooSmall, _p_mvIMPACT__acquire__EInputBufferTooSmallTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValTooSmall, _p_mvIMPACT__acquire__EValTooSmallTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EImplementationMissing, _p_mvIMPACT__acquire__EImplementationMissingTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EPropertyList, _p_mvIMPACT__acquire__EPropertyListTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidFileContent, _p_mvIMPACT__acquire__EInvalidFileContentTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantSerializeData, _p_mvIMPACT__acquire__ECantSerializeDataTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantAllocateNewList, _p_mvIMPACT__acquire__ECantAllocateNewListTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidListID, _p_mvIMPACT__acquire__EInvalidListIDTo_p_mvIMPACT__acquire__EPropertyHandling, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EPropertyList[] = {  {&_swigt__p_mvIMPACT__acquire__ECantRegisterComponent, _p_mvIMPACT__acquire__ECantRegisterComponentTo_p_mvIMPACT__acquire__EPropertyList, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EPropertyList, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentNotFound, _p_mvIMPACT__acquire__EComponentNotFoundTo_p_mvIMPACT__acquire__EPropertyList, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentIDInvalid, _p_mvIMPACT__acquire__EComponentIDInvalidTo_p_mvIMPACT__acquire__EPropertyList, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidListID, _p_mvIMPACT__acquire__EInvalidListIDTo_p_mvIMPACT__acquire__EPropertyList, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EListEntryOccupied, _p_mvIMPACT__acquire__EListEntryOccupiedTo_p_mvIMPACT__acquire__EPropertyList, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantAccessData, _p_mvIMPACT__acquire__ECantAccessDataTo_p_mvIMPACT__acquire__EPropertyList, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ESizeMismatch[] = {  {&_swigt__p_mvIMPACT__acquire__ESizeMismatch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ETranslationTableCorrupted[] = {  {&_swigt__p_mvIMPACT__acquire__ETranslationTableCorrupted, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ETranslationTableNotDefined[] = {  {&_swigt__p_mvIMPACT__acquire__ETranslationTableNotDefined, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EUnsupportedOperation[] = {  {&_swigt__p_mvIMPACT__acquire__EUnsupportedOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EUnsupportedParameter[] = {  {&_swigt__p_mvIMPACT__acquire__EUnsupportedParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EValIDOutOfBounds[] = {  {&_swigt__p_mvIMPACT__acquire__EValIDOutOfBounds, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EValTooLarge[] = {  {&_swigt__p_mvIMPACT__acquire__EValTooLarge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EValTooSmall[] = {  {&_swigt__p_mvIMPACT__acquire__EValTooSmall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EValidationFailed[] = {  {&_swigt__p_mvIMPACT__acquire__EValidationFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EWrongParamCount[] = {  {&_swigt__p_mvIMPACT__acquire__EWrongParamCount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyFT_double_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyI64T_long_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_long_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_int_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAutoNegotiatePacketSizeMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAutoNegotiatePacketSizeMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ExceptionFactory[] = {  {&_swigt__p_mvIMPACT__acquire__ExceptionFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__FirmwareUpdater[] = {  {&_swigt__p_mvIMPACT__acquire__FirmwareUpdater, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__FullSettingsBase[] = {  {&_swigt__p_mvIMPACT__acquire__FullSettingsBase, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__SettingsBlueFOX, _p_mvIMPACT__acquire__SettingsBlueFOXTo_p_mvIMPACT__acquire__FullSettingsBase, 0, 0},  {&_swigt__p_mvIMPACT__acquire__SettingsFrameGrabber, _p_mvIMPACT__acquire__SettingsFrameGrabberTo_p_mvIMPACT__acquire__FullSettingsBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__FunctionInterface[] = {  {&_swigt__p_mvIMPACT__acquire__FunctionInterface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GainOffsetKneeChannelParameters[] = {  {&_swigt__p_mvIMPACT__acquire__GainOffsetKneeChannelParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__AcquisitionControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__AcquisitionControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__ActionControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__ActionControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__AnalogControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__AnalogControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__ChunkDataControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__ChunkDataControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__ColorTransformationControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__ColorTransformationControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__CounterAndTimerControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__CounterAndTimerControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__CustomCommandGenerator[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__CustomCommandGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__DataStreamModule[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__DataStreamModule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__DepthControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__DepthControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__DeviceControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__DeviceControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__DeviceModule[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__DeviceModule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__DigitalIOControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__DigitalIOControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__EncoderControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__EncoderControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__EventControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__EventControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__FileAccessControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__FileAccessControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__ImageFormatControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__ImageFormatControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__InterfaceModule[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__InterfaceModule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__LUTControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__LUTControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__LightControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__LightControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__LogicBlockControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__LogicBlockControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__OpticControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__OpticControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__Scan3dControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__Scan3dControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__SequencerControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__SequencerControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__SoftwareSignalControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__SoftwareSignalControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__SourceControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__SourceControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__SystemModule[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__SystemModule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__TestControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__TestControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__TransferControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__TransferControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__TransportLayerControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__TransportLayerControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__UserSetControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__UserSetControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvCurrentControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvCurrentControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvFFCControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvFFCControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvFrameAverageControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvFrameAverageControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvHDRControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvHDRControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvLensControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvLensControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvLogicGateControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvLogicGateControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__HDRControl[] = {  {&_swigt__p_mvIMPACT__acquire__HDRControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__HDRKneePoint[] = {  {&_swigt__p_mvIMPACT__acquire__HDRKneePoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__I2CControl[] = {  {&_swigt__p_mvIMPACT__acquire__I2CControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__IOSubSystem[] = {  {&_swigt__p_mvIMPACT__acquire__IOSubSystemCommon, _p_mvIMPACT__acquire__IOSubSystemCommonTo_p_mvIMPACT__acquire__IOSubSystem, 0, 0},  {&_swigt__p_mvIMPACT__acquire__IOSubSystem, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__IOSubSystemFrameGrabber, _p_mvIMPACT__acquire__IOSubSystemFrameGrabberTo_p_mvIMPACT__acquire__IOSubSystem, 0, 0},  {&_swigt__p_mvIMPACT__acquire__IOSubSystemBlueFOX, _p_mvIMPACT__acquire__IOSubSystemBlueFOXTo_p_mvIMPACT__acquire__IOSubSystem, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__IOSubSystemBlueFOX[] = {  {&_swigt__p_mvIMPACT__acquire__IOSubSystemBlueFOX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__IOSubSystemCommon[] = {  {&_swigt__p_mvIMPACT__acquire__IOSubSystemCommon, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__IOSubSystemFrameGrabber, _p_mvIMPACT__acquire__IOSubSystemFrameGrabberTo_p_mvIMPACT__acquire__IOSubSystemCommon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__IOSubSystemFrameGrabber[] = {  {&_swigt__p_mvIMPACT__acquire__IOSubSystemFrameGrabber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ImageBuffer[] = {  {&_swigt__p_mvIMPACT__acquire__ImageBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ImageBufferDesc[] = {  {&_swigt__p_mvIMPACT__acquire__ImageBufferDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ImageDestination[] = {  {&_swigt__p_mvIMPACT__acquire__ImageDestination, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ImageMemoryManager[] = {  {&_swigt__p_mvIMPACT__acquire__ImageMemoryManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ImageProcessing[] = {  {&_swigt__p_mvIMPACT__acquire__ImageProcessing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ImageRequestControl[] = {  {&_swigt__p_mvIMPACT__acquire__ImageRequestControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__ImpactAcquireException[] = {  {&_swigt__p_mvIMPACT__acquire__EValTooLarge, _p_mvIMPACT__acquire__EValTooLargeTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EIncompatibleComponents, _p_mvIMPACT__acquire__EIncompatibleComponentsTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidValue, _p_mvIMPACT__acquire__EInvalidValueTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValidationFailed, _p_mvIMPACT__acquire__EValidationFailedTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EWrongParamCount, _p_mvIMPACT__acquire__EWrongParamCountTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoReadRights, _p_mvIMPACT__acquire__ENoReadRightsTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentNotFound, _p_mvIMPACT__acquire__EComponentNotFoundTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EUnsupportedOperation, _p_mvIMPACT__acquire__EUnsupportedOperationTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidValueType, _p_mvIMPACT__acquire__EInvalidValueTypeTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoWriteRights, _p_mvIMPACT__acquire__ENoWriteRightsTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoModifySizeRights, _p_mvIMPACT__acquire__ENoModifySizeRightsTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableCorrupted, _p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidParameterList, _p_mvIMPACT__acquire__EInvalidParameterListTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EMethod, _p_mvIMPACT__acquire__EMethodTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAMethod, _p_mvIMPACT__acquire__ENotAMethodTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantRegisterComponent, _p_mvIMPACT__acquire__ECantRegisterComponentTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponent, _p_mvIMPACT__acquire__EComponentTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAList, _p_mvIMPACT__acquire__ENotAListTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ESizeMismatch, _p_mvIMPACT__acquire__ESizeMismatchTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EListEntryOccupied, _p_mvIMPACT__acquire__EListEntryOccupiedTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantAccessData, _p_mvIMPACT__acquire__ECantAccessDataTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentIDInvalid, _p_mvIMPACT__acquire__EComponentIDInvalidTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EMethodPtrInvalid, _p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableNotDefined, _p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ImpactAcquireException, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidInputParameter, _p_mvIMPACT__acquire__EInvalidInputParameterTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EUnsupportedParameter, _p_mvIMPACT__acquire__EUnsupportedParameterTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAProperty, _p_mvIMPACT__acquire__ENotAPropertyTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EProperty, _p_mvIMPACT__acquire__EPropertyTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValIDOutOfBounds, _p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EPropertyHandling, _p_mvIMPACT__acquire__EPropertyHandlingTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValTooSmall, _p_mvIMPACT__acquire__EValTooSmallTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInputBufferTooSmall, _p_mvIMPACT__acquire__EInputBufferTooSmallTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EImplementationMissing, _p_mvIMPACT__acquire__EImplementationMissingTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EPropertyList, _p_mvIMPACT__acquire__EPropertyListTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidFileContent, _p_mvIMPACT__acquire__EInvalidFileContentTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantSerializeData, _p_mvIMPACT__acquire__ECantSerializeDataTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantAllocateNewList, _p_mvIMPACT__acquire__ECantAllocateNewListTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidListID, _p_mvIMPACT__acquire__EInvalidListIDTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EDeviceManager, _p_mvIMPACT__acquire__EDeviceManagerTo_p_mvIMPACT__acquire__ImpactAcquireException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__Info[] = {  {&_swigt__p_mvIMPACT__acquire__Info, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__InfoBlueCOUGAR, _p_mvIMPACT__acquire__InfoBlueCOUGARTo_p_mvIMPACT__acquire__Info, 0, 0},  {&_swigt__p_mvIMPACT__acquire__InfoBlueFOX, _p_mvIMPACT__acquire__InfoBlueFOXTo_p_mvIMPACT__acquire__Info, 0, 0},  {&_swigt__p_mvIMPACT__acquire__InfoBlueDevice, _p_mvIMPACT__acquire__InfoBlueDeviceTo_p_mvIMPACT__acquire__Info, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__InfoBlueCOUGAR[] = {  {&_swigt__p_mvIMPACT__acquire__InfoBlueCOUGAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__InfoBlueDevice[] = {  {&_swigt__p_mvIMPACT__acquire__InfoBlueCOUGAR, _p_mvIMPACT__acquire__InfoBlueCOUGARTo_p_mvIMPACT__acquire__InfoBlueDevice, 0, 0},  {&_swigt__p_mvIMPACT__acquire__InfoBlueFOX, _p_mvIMPACT__acquire__InfoBlueFOXTo_p_mvIMPACT__acquire__InfoBlueDevice, 0, 0},  {&_swigt__p_mvIMPACT__acquire__InfoBlueDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__InfoBlueFOX[] = {  {&_swigt__p_mvIMPACT__acquire__InfoBlueFOX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__LUTParameters[] = {  {&_swigt__p_mvIMPACT__acquire__LUTParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__Method[] = {  {&_swigt__p_mvIMPACT__acquire__Method, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__MirrorParameters[] = {  {&_swigt__p_mvIMPACT__acquire__MirrorParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__MotorFocusControl[] = {  {&_swigt__p_mvIMPACT__acquire__MotorFocusControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice[] = {  {&_swigt__p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber[] = {  {&_swigt__p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__Property[] = {  {&_swigt__p_mvIMPACT__acquire__PropertyPtr, _p_mvIMPACT__acquire__PropertyPtrTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t, _p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, _p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__Property, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyFT_double_t, _p_mvIMPACT__acquire__EnumPropertyFT_double_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_long_t, _p_mvIMPACT__acquire__EnumPropertyI64T_long_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_int_t, _p_mvIMPACT__acquire__EnumPropertyIT_int_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__PropertyS, _p_mvIMPACT__acquire__PropertySTo_p_mvIMPACT__acquire__Property, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__PropertyPtr[] = {  {&_swigt__p_mvIMPACT__acquire__PropertyPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__PropertyS[] = {  {&_swigt__p_mvIMPACT__acquire__PropertyS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__PulseStartConfiguration[] = {  {&_swigt__p_mvIMPACT__acquire__PulseStartConfiguration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__RTCtrProgram[] = {  {&_swigt__p_mvIMPACT__acquire__RTCtrProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__RTCtrProgramStep[] = {  {&_swigt__p_mvIMPACT__acquire__RTCtrProgramStep, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__Request[] = {  {&_swigt__p_mvIMPACT__acquire__Request, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__RequestFactory[] = {  {&_swigt__p_mvIMPACT__acquire__RequestFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__RequestInfoConfiguration[] = {  {&_swigt__p_mvIMPACT__acquire__RequestInfoConfiguration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__SettingsBlueFOX[] = {  {&_swigt__p_mvIMPACT__acquire__SettingsBlueFOX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__SettingsFrameGrabber[] = {  {&_swigt__p_mvIMPACT__acquire__SettingsFrameGrabber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__Statistics[] = {  {&_swigt__p_mvIMPACT__acquire__Statistics, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__SyncOutput[] = {  {&_swigt__p_mvIMPACT__acquire__SyncOutput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__SystemBlueFOX[] = {  {&_swigt__p_mvIMPACT__acquire__SystemBlueFOX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__SystemSettings[] = {  {&_swigt__p_mvIMPACT__acquire__SystemBlueFOX, _p_mvIMPACT__acquire__SystemBlueFOXTo_p_mvIMPACT__acquire__SystemSettings, 0, 0},  {&_swigt__p_mvIMPACT__acquire__SystemV4L2, _p_mvIMPACT__acquire__SystemV4L2To_p_mvIMPACT__acquire__SystemSettings, 0, 0},  {&_swigt__p_mvIMPACT__acquire__SystemSettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__SystemV4L2[] = {  {&_swigt__p_mvIMPACT__acquire__SystemV4L2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TriggerControl[] = {  {&_swigt__p_mvIMPACT__acquire__TriggerControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__UserData[] = {  {&_swigt__p_mvIMPACT__acquire__UserData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__UserDataEntry[] = {  {&_swigt__p_mvIMPACT__acquire__UserDataEntry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__WhiteBalanceSettings[] = {  {&_swigt__p_mvIMPACT__acquire__WhiteBalanceSettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__WhiteBalancer[] = {  {&_swigt__p_mvIMPACT__acquire__WhiteBalancer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__labs__VideoStream[] = {  {&_swigt__p_mvIMPACT__acquire__labs__VideoStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__labs__VideoStreamPauseScope[] = {  {&_swigt__p_mvIMPACT__acquire__labs__VideoStreamPauseScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_second_type[] = {  {&_swigt__p_second_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t_t[] = {  {&_swigt__p_std__mapT_std__string_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_double_t[] = {  {&_swigt__p_std__pairT_std__string_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_int_t[] = {  {&_swigt__p_std__pairT_std__string_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_long_t[] = {  {&_swigt__p_std__pairT_std__string_long_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t[] = {  {&_swigt__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__runtime_error[] = {  {&_swigt__p_mvIMPACT__acquire__EValTooLarge, _p_mvIMPACT__acquire__EValTooLargeTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EIncompatibleComponents, _p_mvIMPACT__acquire__EIncompatibleComponentsTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidValue, _p_mvIMPACT__acquire__EInvalidValueTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValidationFailed, _p_mvIMPACT__acquire__EValidationFailedTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EWrongParamCount, _p_mvIMPACT__acquire__EWrongParamCountTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoReadRights, _p_mvIMPACT__acquire__ENoReadRightsTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentNotFound, _p_mvIMPACT__acquire__EComponentNotFoundTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EUnsupportedOperation, _p_mvIMPACT__acquire__EUnsupportedOperationTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidValueType, _p_mvIMPACT__acquire__EInvalidValueTypeTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoWriteRights, _p_mvIMPACT__acquire__ENoWriteRightsTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENoModifySizeRights, _p_mvIMPACT__acquire__ENoModifySizeRightsTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableCorrupted, _p_mvIMPACT__acquire__ETranslationTableCorruptedTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidParameterList, _p_mvIMPACT__acquire__EInvalidParameterListTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EMethod, _p_mvIMPACT__acquire__EMethodTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAMethod, _p_mvIMPACT__acquire__ENotAMethodTo_p_std__runtime_error, 0, 0},  {&_swigt__p_std__runtime_error, 0, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantRegisterComponent, _p_mvIMPACT__acquire__ECantRegisterComponentTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponent, _p_mvIMPACT__acquire__EComponentTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAList, _p_mvIMPACT__acquire__ENotAListTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ESizeMismatch, _p_mvIMPACT__acquire__ESizeMismatchTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EListEntryOccupied, _p_mvIMPACT__acquire__EListEntryOccupiedTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantAccessData, _p_mvIMPACT__acquire__ECantAccessDataTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EComponentIDInvalid, _p_mvIMPACT__acquire__EComponentIDInvalidTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EMethodPtrInvalid, _p_mvIMPACT__acquire__EMethodPtrInvalidTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ETranslationTableNotDefined, _p_mvIMPACT__acquire__ETranslationTableNotDefinedTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ImpactAcquireException, _p_mvIMPACT__acquire__ImpactAcquireExceptionTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidInputParameter, _p_mvIMPACT__acquire__EInvalidInputParameterTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EUnsupportedParameter, _p_mvIMPACT__acquire__EUnsupportedParameterTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ENotAProperty, _p_mvIMPACT__acquire__ENotAPropertyTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EProperty, _p_mvIMPACT__acquire__EPropertyTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValIDOutOfBounds, _p_mvIMPACT__acquire__EValIDOutOfBoundsTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EValTooSmall, _p_mvIMPACT__acquire__EValTooSmallTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EPropertyHandling, _p_mvIMPACT__acquire__EPropertyHandlingTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInputBufferTooSmall, _p_mvIMPACT__acquire__EInputBufferTooSmallTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EImplementationMissing, _p_mvIMPACT__acquire__EImplementationMissingTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EPropertyList, _p_mvIMPACT__acquire__EPropertyListTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidFileContent, _p_mvIMPACT__acquire__EInvalidFileContentTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantSerializeData, _p_mvIMPACT__acquire__ECantSerializeDataTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__ECantAllocateNewList, _p_mvIMPACT__acquire__ECantAllocateNewListTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EInvalidListID, _p_mvIMPACT__acquire__EInvalidListIDTo_p_std__runtime_error, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EDeviceManager, _p_mvIMPACT__acquire__EDeviceManagerTo_p_std__runtime_error, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_mvIMPACT__acquire__Component_std__allocatorT_mvIMPACT__acquire__Component_t_t[] = {  {&_swigt__p_std__vectorT_mvIMPACT__acquire__Component_std__allocatorT_mvIMPACT__acquire__Component_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_std__allocatorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_t_t[] = {  {&_swigt__p_std__vectorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_std__allocatorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_std__allocatorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_std__allocatorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_void_p_std__allocatorT_void_p_t_t[] = {  {&_swigt__p_std__vectorT_void_p_std__allocatorT_void_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_uint16_t[] = {  {&_swigt__p_uint16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_uint32_t[] = {  {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_char,
  _swigc__p_first_type,
  _swigc__p_int,
  _swigc__p_int16_t,
  _swigc__p_int32_t,
  _swigc__p_long,
  _swigc__p_mvIMPACT__acquire__AutoControlParameters,
  _swigc__p_mvIMPACT__acquire__BasicDeviceSettings,
  _swigc__p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI,
  _swigc__p_mvIMPACT__acquire__BufferPart,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionBase,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionCameraLink,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionDigital,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionDigitalBase,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionDigitalBase2,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionManager,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionNonStandard,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionSDI,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionStandard,
  _swigc__p_mvIMPACT__acquire__CameraDescriptionStandardBase,
  _swigc__p_mvIMPACT__acquire__CameraSettingsBase,
  _swigc__p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR,
  _swigc__p_mvIMPACT__acquire__CameraSettingsBlueDevice,
  _swigc__p_mvIMPACT__acquire__CameraSettingsBlueFOX,
  _swigc__p_mvIMPACT__acquire__CameraSettingsFrameGrabber,
  _swigc__p_mvIMPACT__acquire__CameraSettingsV4L2Device,
  _swigc__p_mvIMPACT__acquire__CameraSettingsVirtualDevice,
  _swigc__p_mvIMPACT__acquire__ChannelData,
  _swigc__p_mvIMPACT__acquire__Component,
  _swigc__p_mvIMPACT__acquire__ComponentAccess,
  _swigc__p_mvIMPACT__acquire__ComponentCallback,
  _swigc__p_mvIMPACT__acquire__ComponentCollection,
  _swigc__p_mvIMPACT__acquire__ComponentList,
  _swigc__p_mvIMPACT__acquire__ComponentLocator,
  _swigc__p_mvIMPACT__acquire__ComponentLocatorBase,
  _swigc__p_mvIMPACT__acquire__Connector,
  _swigc__p_mvIMPACT__acquire__Device,
  _swigc__p_mvIMPACT__acquire__DeviceComponentLocator,
  _swigc__p_mvIMPACT__acquire__DeviceManager,
  _swigc__p_mvIMPACT__acquire__DigitalIOMeasurementControl,
  _swigc__p_mvIMPACT__acquire__DigitalInput,
  _swigc__p_mvIMPACT__acquire__DigitalOutput,
  _swigc__p_mvIMPACT__acquire__ECantAccessData,
  _swigc__p_mvIMPACT__acquire__ECantAllocateNewList,
  _swigc__p_mvIMPACT__acquire__ECantRegisterComponent,
  _swigc__p_mvIMPACT__acquire__ECantSerializeData,
  _swigc__p_mvIMPACT__acquire__EComponent,
  _swigc__p_mvIMPACT__acquire__EComponentIDInvalid,
  _swigc__p_mvIMPACT__acquire__EComponentNotFound,
  _swigc__p_mvIMPACT__acquire__EDeviceManager,
  _swigc__p_mvIMPACT__acquire__EImplementationMissing,
  _swigc__p_mvIMPACT__acquire__EIncompatibleComponents,
  _swigc__p_mvIMPACT__acquire__EInputBufferTooSmall,
  _swigc__p_mvIMPACT__acquire__EInvalidFileContent,
  _swigc__p_mvIMPACT__acquire__EInvalidInputParameter,
  _swigc__p_mvIMPACT__acquire__EInvalidListID,
  _swigc__p_mvIMPACT__acquire__EInvalidParameterList,
  _swigc__p_mvIMPACT__acquire__EInvalidValue,
  _swigc__p_mvIMPACT__acquire__EInvalidValueType,
  _swigc__p_mvIMPACT__acquire__EListEntryOccupied,
  _swigc__p_mvIMPACT__acquire__EMethod,
  _swigc__p_mvIMPACT__acquire__EMethodPtrInvalid,
  _swigc__p_mvIMPACT__acquire__ENoModifySizeRights,
  _swigc__p_mvIMPACT__acquire__ENoReadRights,
  _swigc__p_mvIMPACT__acquire__ENoWriteRights,
  _swigc__p_mvIMPACT__acquire__ENotAList,
  _swigc__p_mvIMPACT__acquire__ENotAMethod,
  _swigc__p_mvIMPACT__acquire__ENotAProperty,
  _swigc__p_mvIMPACT__acquire__EProperty,
  _swigc__p_mvIMPACT__acquire__EPropertyHandling,
  _swigc__p_mvIMPACT__acquire__EPropertyList,
  _swigc__p_mvIMPACT__acquire__ESizeMismatch,
  _swigc__p_mvIMPACT__acquire__ETranslationTableCorrupted,
  _swigc__p_mvIMPACT__acquire__ETranslationTableNotDefined,
  _swigc__p_mvIMPACT__acquire__EUnsupportedOperation,
  _swigc__p_mvIMPACT__acquire__EUnsupportedParameter,
  _swigc__p_mvIMPACT__acquire__EValIDOutOfBounds,
  _swigc__p_mvIMPACT__acquire__EValTooLarge,
  _swigc__p_mvIMPACT__acquire__EValTooSmall,
  _swigc__p_mvIMPACT__acquire__EValidationFailed,
  _swigc__p_mvIMPACT__acquire__EWrongParamCount,
  _swigc__p_mvIMPACT__acquire__EnumPropertyFT_double_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyI64T_long_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TBufferPartDataType_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_int_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAutoNegotiatePacketSizeMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t,
  _swigc__p_mvIMPACT__acquire__ExceptionFactory,
  _swigc__p_mvIMPACT__acquire__FirmwareUpdater,
  _swigc__p_mvIMPACT__acquire__FullSettingsBase,
  _swigc__p_mvIMPACT__acquire__FunctionInterface,
  _swigc__p_mvIMPACT__acquire__GainOffsetKneeChannelParameters,
  _swigc__p_mvIMPACT__acquire__GenICam__AcquisitionControl,
  _swigc__p_mvIMPACT__acquire__GenICam__ActionControl,
  _swigc__p_mvIMPACT__acquire__GenICam__AnalogControl,
  _swigc__p_mvIMPACT__acquire__GenICam__ChunkDataControl,
  _swigc__p_mvIMPACT__acquire__GenICam__ColorTransformationControl,
  _swigc__p_mvIMPACT__acquire__GenICam__CounterAndTimerControl,
  _swigc__p_mvIMPACT__acquire__GenICam__CustomCommandGenerator,
  _swigc__p_mvIMPACT__acquire__GenICam__DataStreamModule,
  _swigc__p_mvIMPACT__acquire__GenICam__DepthControl,
  _swigc__p_mvIMPACT__acquire__GenICam__DeviceControl,
  _swigc__p_mvIMPACT__acquire__GenICam__DeviceModule,
  _swigc__p_mvIMPACT__acquire__GenICam__DigitalIOControl,
  _swigc__p_mvIMPACT__acquire__GenICam__EncoderControl,
  _swigc__p_mvIMPACT__acquire__GenICam__EventControl,
  _swigc__p_mvIMPACT__acquire__GenICam__FileAccessControl,
  _swigc__p_mvIMPACT__acquire__GenICam__GenTLDriverConfigurator,
  _swigc__p_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration,
  _swigc__p_mvIMPACT__acquire__GenICam__ImageFormatControl,
  _swigc__p_mvIMPACT__acquire__GenICam__InterfaceModule,
  _swigc__p_mvIMPACT__acquire__GenICam__LUTControl,
  _swigc__p_mvIMPACT__acquire__GenICam__LightControl,
  _swigc__p_mvIMPACT__acquire__GenICam__LogicBlockControl,
  _swigc__p_mvIMPACT__acquire__GenICam__OpticControl,
  _swigc__p_mvIMPACT__acquire__GenICam__Scan3dControl,
  _swigc__p_mvIMPACT__acquire__GenICam__SequencerControl,
  _swigc__p_mvIMPACT__acquire__GenICam__SoftwareSignalControl,
  _swigc__p_mvIMPACT__acquire__GenICam__SourceControl,
  _swigc__p_mvIMPACT__acquire__GenICam__SystemModule,
  _swigc__p_mvIMPACT__acquire__GenICam__TestControl,
  _swigc__p_mvIMPACT__acquire__GenICam__TransferControl,
  _swigc__p_mvIMPACT__acquire__GenICam__TransportLayerControl,
  _swigc__p_mvIMPACT__acquire__GenICam__UserSetControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvAutoFeatureControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvCurrentControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvDefectivePixelCorrectionControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvFFCControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvFrameAverageControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvHDRControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvI2cInterfaceControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvLensControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvLogicGateControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvSerialInterfaceControl,
  _swigc__p_mvIMPACT__acquire__HDRControl,
  _swigc__p_mvIMPACT__acquire__HDRKneePoint,
  _swigc__p_mvIMPACT__acquire__I2CControl,
  _swigc__p_mvIMPACT__acquire__IOSubSystem,
  _swigc__p_mvIMPACT__acquire__IOSubSystemBlueFOX,
  _swigc__p_mvIMPACT__acquire__IOSubSystemCommon,
  _swigc__p_mvIMPACT__acquire__IOSubSystemFrameGrabber,
  _swigc__p_mvIMPACT__acquire__ImageBuffer,
  _swigc__p_mvIMPACT__acquire__ImageBufferDesc,
  _swigc__p_mvIMPACT__acquire__ImageDestination,
  _swigc__p_mvIMPACT__acquire__ImageMemoryManager,
  _swigc__p_mvIMPACT__acquire__ImageProcessing,
  _swigc__p_mvIMPACT__acquire__ImageRequestControl,
  _swigc__p_mvIMPACT__acquire__ImpactAcquireException,
  _swigc__p_mvIMPACT__acquire__Info,
  _swigc__p_mvIMPACT__acquire__InfoBlueCOUGAR,
  _swigc__p_mvIMPACT__acquire__InfoBlueDevice,
  _swigc__p_mvIMPACT__acquire__InfoBlueFOX,
  _swigc__p_mvIMPACT__acquire__LUTParameters,
  _swigc__p_mvIMPACT__acquire__Method,
  _swigc__p_mvIMPACT__acquire__MirrorParameters,
  _swigc__p_mvIMPACT__acquire__MotorFocusControl,
  _swigc__p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice,
  _swigc__p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber,
  _swigc__p_mvIMPACT__acquire__Property,
  _swigc__p_mvIMPACT__acquire__PropertyPtr,
  _swigc__p_mvIMPACT__acquire__PropertyS,
  _swigc__p_mvIMPACT__acquire__PulseStartConfiguration,
  _swigc__p_mvIMPACT__acquire__RTCtrProgram,
  _swigc__p_mvIMPACT__acquire__RTCtrProgramStep,
  _swigc__p_mvIMPACT__acquire__Request,
  _swigc__p_mvIMPACT__acquire__RequestFactory,
  _swigc__p_mvIMPACT__acquire__RequestInfoConfiguration,
  _swigc__p_mvIMPACT__acquire__SettingsBlueFOX,
  _swigc__p_mvIMPACT__acquire__SettingsFrameGrabber,
  _swigc__p_mvIMPACT__acquire__Statistics,
  _swigc__p_mvIMPACT__acquire__SyncOutput,
  _swigc__p_mvIMPACT__acquire__SystemBlueFOX,
  _swigc__p_mvIMPACT__acquire__SystemSettings,
  _swigc__p_mvIMPACT__acquire__SystemV4L2,
  _swigc__p_mvIMPACT__acquire__TriggerControl,
  _swigc__p_mvIMPACT__acquire__UserData,
  _swigc__p_mvIMPACT__acquire__UserDataEntry,
  _swigc__p_mvIMPACT__acquire__WhiteBalanceSettings,
  _swigc__p_mvIMPACT__acquire__WhiteBalancer,
  _swigc__p_mvIMPACT__acquire__labs__VideoStream,
  _swigc__p_mvIMPACT__acquire__labs__VideoStreamPauseScope,
  _swigc__p_second_type,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__mapT_std__string_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t_t,
  _swigc__p_std__pairT_std__string_double_t,
  _swigc__p_std__pairT_std__string_int_t,
  _swigc__p_std__pairT_std__string_long_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TInterfaceEnumerationBehaviour_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t,
  _swigc__p_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t,
  _swigc__p_std__runtime_error,
  _swigc__p_std__string,
  _swigc__p_std__vectorT_mvIMPACT__acquire__Component_std__allocatorT_mvIMPACT__acquire__Component_t_t,
  _swigc__p_std__vectorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_std__allocatorT_mvIMPACT__acquire__GenICam__GenTLProducerConfiguration_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_std__allocatorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t_t,
  _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  _swigc__p_std__vectorT_void_p_std__allocatorT_void_p_t_t,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_uint16_t,
  _swigc__p_uint32_t,
  _swigc__p_unsigned_long,
  _swigc__p_void,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
  
  /* -----------------------------------------------------------------------------
   * global variable support code.
   * ----------------------------------------------------------------------------- */
  
  typedef struct swig_globalvar {
    char       *name;                  /* Name of global variable */
    PyObject *(*get_attr)(void);       /* Return the current value */
    int       (*set_attr)(PyObject *); /* Set the value */
    struct swig_globalvar *next;
  } swig_globalvar;
  
  typedef struct swig_varlinkobject {
    PyObject_HEAD
    swig_globalvar *vars;
  } swig_varlinkobject;
  
  SWIGINTERN PyObject *
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
    return PyUnicode_InternFromString("<Swig global variables>");
#else
    return PyString_FromString("<Swig global variables>");
#endif
  }
  
  SWIGINTERN PyObject *
  swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *str = PyUnicode_InternFromString("(");
    PyObject *tail;
    PyObject *joined;
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      tail = PyUnicode_FromString(var->name);
      joined = PyUnicode_Concat(str, tail);
      Py_DecRef(str);
      Py_DecRef(tail);
      str = joined;
      if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
      }
    }
    tail = PyUnicode_InternFromString(")");
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
#else
    PyObject *str = PyString_FromString("(");
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
    }
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
    return str;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    PyObject *res = NULL;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->get_attr)();
        break;
      }
      var = var->next;
    }
    if (res == NULL && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN int
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
    int res = 1;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->set_attr)(p);
        break;
      }
      var = var->next;
    }
    if (res == 1 && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN PyTypeObject*
  swig_varlink_type(void) {
    static char varlink__doc__[] = "Swig var link object";
    static PyTypeObject varlink_type;
    static int type_init = 0;
    if (!type_init) {
      const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        "swigvarlink",                      /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        0,                                  /* tp_print */
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
        0,                                  /* tp_compare */
        (reprfunc) swig_varlink_repr,       /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                                  /* tp_call */
        (reprfunc) swig_varlink_str,        /* tp_str */
        0,                                  /* tp_getattro */
        0,                                  /* tp_setattro */
        0,                                  /* tp_as_buffer */
        0,                                  /* tp_flags */
        varlink__doc__,                     /* tp_doc */
        0,                                  /* tp_traverse */
        0,                                  /* tp_clear */
        0,                                  /* tp_richcompare */
        0,                                  /* tp_weaklistoffset */
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
        0,                                  /* tp_del */
        0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
        0,                                  /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
        0,                                  /* tp_allocs */
        0,                                  /* tp_frees */
        0,                                  /* tp_maxalloc */
        0,                                  /* tp_prev */
        0                                   /* tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    }
    return &varlink_type;
  }
  
  /* Create a variable linking object for use later */
  SWIGINTERN PyObject *
  SWIG_Python_newvarlink(void) {
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
    if (result) {
      result->vars = 0;
    }
    return ((PyObject*) result);
  }
  
  SWIGINTERN void 
  SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
    swig_varlinkobject *v = (swig_varlinkobject *) p;
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
    if (gv) {
      size_t size = strlen(name)+1;
      gv->name = (char *)malloc(size);
      if (gv->name) {
        memcpy(gv->name, name, size);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
      }
    }
    v->vars = gv;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *globals = 0;
    if (!globals) {
      globals = SWIG_newvarlink();
    }
    return globals;
  }
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    swig_const_info *const_table,
    swig_type_info **types,
    swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
  /* -----------------------------------------------------------------------------
   * Method creation and docstring support functions
   * ----------------------------------------------------------------------------- */
  
  /* -----------------------------------------------------------------------------
   * Function to find the method definition with the correct docstring for the
   * proxy module as opposed to the low-level API
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
    /* Find the function in the modified method table */
    size_t offset = 0;
    int found = 0;
    while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
      if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
        found = 1;
        break;
      }
      offset++;
    }
    /* Use the copy with the modified docstring if available */
    return found ? &SwigMethods_proxydocs[offset] : NULL;
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyInstanceMethod_New() used in Python 3
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
#if PY_VERSION_HEX >= 0x03000000
    return PyInstanceMethod_New(func);
#else
    return PyMethod_New(func, NULL, NULL);
#endif
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyStaticMethod_New()
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
    return PyStaticMethod_New(func);
  }
  
#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule(SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  PyDict_SetItemString(md, "cvar", globals);
  Py_DECREF(globals);
  SWIG_addvarlink(globals, "INVALID_ID", Swig_var_INVALID_ID_get, Swig_var_INVALID_ID_set);
  SWIG_addvarlink(globals, "ROOT_LIST", Swig_var_ROOT_LIST_get, Swig_var_ROOT_LIST_set);
  SWIG_addvarlink(globals, "END_OF_LIST", Swig_var_END_OF_LIST_get, Swig_var_END_OF_LIST_set);
  SWIG_addvarlink(globals, "smIgnoreLists", Swig_var_smIgnoreLists_get, Swig_var_smIgnoreLists_set);
  SWIG_addvarlink(globals, "smIgnoreMethods", Swig_var_smIgnoreMethods_get, Swig_var_smIgnoreMethods_set);
  SWIG_addvarlink(globals, "smIgnoreProperties", Swig_var_smIgnoreProperties_get, Swig_var_smIgnoreProperties_set);
  SWIG_Python_SetConstant(d, "ctOnChanged",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctOnChanged)));
  SWIG_Python_SetConstant(d, "ctOnReadData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctOnReadData)));
  SWIG_Python_SetConstant(d, "ctOnWriteData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctOnWriteData)));
  SWIG_Python_SetConstant(d, "ctOnRefreshCache",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctOnRefreshCache)));
  SWIG_Python_SetConstant(d, "cfUndefined",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfUndefined)));
  SWIG_Python_SetConstant(d, "cfReadAccess",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfReadAccess)));
  SWIG_Python_SetConstant(d, "cfWriteAccess",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfWriteAccess)));
  SWIG_Python_SetConstant(d, "cfRWAccess",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfRWAccess)));
  SWIG_Python_SetConstant(d, "cfFixedSize",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfFixedSize)));
  SWIG_Python_SetConstant(d, "cfInvisible",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfInvisible)));
  SWIG_Python_SetConstant(d, "cfAllowValueCombinations",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfAllowValueCombinations)));
  SWIG_Python_SetConstant(d, "cfShouldBeDisplayedAsList",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfShouldBeDisplayedAsList)));
  SWIG_Python_SetConstant(d, "cfDisallowSerialize",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfDisallowSerialize)));
  SWIG_Python_SetConstant(d, "cfAlwaysForceClone",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfAlwaysForceClone)));
  SWIG_Python_SetConstant(d, "cfNotAvailable",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfNotAvailable)));
  SWIG_Python_SetConstant(d, "cfNotImplemented",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfNotImplemented)));
  SWIG_Python_SetConstant(d, "cfContainsBinaryData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfContainsBinaryData)));
  SWIG_Python_SetConstant(d, "cfShouldBeDisplayedAsEnumeration",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfShouldBeDisplayedAsEnumeration)));
  SWIG_Python_SetConstant(d, "cfAlwaysForceUpdate",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfAlwaysForceUpdate)));
  SWIG_Python_SetConstant(d, "vtInt",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vtInt)));
  SWIG_Python_SetConstant(d, "vtFloat",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vtFloat)));
  SWIG_Python_SetConstant(d, "vtPtr",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vtPtr)));
  SWIG_Python_SetConstant(d, "vtString",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vtString)));
  SWIG_Python_SetConstant(d, "vtInt64",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vtInt64)));
  SWIG_Python_SetConstant(d, "crUndefined",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crUndefined)));
  SWIG_Python_SetConstant(d, "crLinear",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crLinear)));
  SWIG_Python_SetConstant(d, "crLogarithmic",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crLogarithmic)));
  SWIG_Python_SetConstant(d, "crBoolean",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crBoolean)));
  SWIG_Python_SetConstant(d, "crPureNumber",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crPureNumber)));
  SWIG_Python_SetConstant(d, "crHexNumber",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crHexNumber)));
  SWIG_Python_SetConstant(d, "crIPv4Address",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crIPv4Address)));
  SWIG_Python_SetConstant(d, "crMACAddress",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crMACAddress)));
  SWIG_Python_SetConstant(d, "crFileName",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crFileName)));
  SWIG_Python_SetConstant(d, "crDirectoryName",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::crDirectoryName)));
  SWIG_Python_SetConstant(d, "ctProp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctProp)));
  SWIG_Python_SetConstant(d, "ctList",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctList)));
  SWIG_Python_SetConstant(d, "ctMeth",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctMeth)));
  SWIG_Python_SetConstant(d, "ctPropInt",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctPropInt)));
  SWIG_Python_SetConstant(d, "ctPropFloat",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctPropFloat)));
  SWIG_Python_SetConstant(d, "ctPropString",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctPropString)));
  SWIG_Python_SetConstant(d, "ctPropPtr",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctPropPtr)));
  SWIG_Python_SetConstant(d, "ctPropInt64",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctPropInt64)));
  SWIG_Python_SetConstant(d, "cvBeginner",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cvBeginner)));
  SWIG_Python_SetConstant(d, "cvExpert",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cvExpert)));
  SWIG_Python_SetConstant(d, "cvGuru",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cvGuru)));
  SWIG_Python_SetConstant(d, "cvInvisible",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cvInvisible)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_NO_ERROR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_NO_ERROR)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_NOT_A_LIST",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_NOT_A_LIST)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_NOT_A_PROPERTY",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_NOT_A_PROPERTY)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_NOT_A_METHOD",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_NOT_A_METHOD)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_NO_READ_RIGHTS",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_NO_READ_RIGHTS)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_NO_WRITE_RIGHTS",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_NO_WRITE_RIGHTS)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_NO_MODIFY_SIZE_RIGHTS",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_NO_MODIFY_SIZE_RIGHTS)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_INCOMPATIBLE_COMPONENTS",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_INCOMPATIBLE_COMPONENTS)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_UNSUPPORTED_PARAMETER",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_UNSUPPORTED_PARAMETER)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_SIZE_MISMATCH",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_SIZE_MISMATCH)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_IMPLEMENTATION_MISSING",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_IMPLEMENTATION_MISSING)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_ACCESSTOKEN_CREATION_FAILED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_ACCESSTOKEN_CREATION_FAILED)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_INVALID_PROP_VALUE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_INVALID_PROP_VALUE)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_PROP_TRANSLATION_TABLE_CORRUPTED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_PROP_TRANSLATION_TABLE_CORRUPTED)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_PROP_VAL_ID_OUT_OF_BOUNDS",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_PROP_VAL_ID_OUT_OF_BOUNDS)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_PROP_TRANSLATION_TABLE_NOT_DEFINED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_PROP_TRANSLATION_TABLE_NOT_DEFINED)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_INVALID_PROP_VALUE_TYPE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_INVALID_PROP_VALUE_TYPE)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_PROP_VAL_TOO_LARGE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_PROP_VAL_TOO_LARGE)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_PROP_VAL_TOO_SMALL",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_PROP_VAL_TOO_SMALL)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_COMPONENT_NOT_FOUND",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_COMPONENT_NOT_FOUND)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_LIST_ID_INVALID",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_LIST_ID_INVALID)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_COMPONENT_ID_INVALID",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_COMPONENT_ID_INVALID)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_LIST_ENTRY_OCCUPIED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_LIST_ENTRY_OCCUPIED)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_COMPONENT_HAS_OWNER_ALREADY",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_COMPONENT_HAS_OWNER_ALREADY)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_COMPONENT_ALREADY_REGISTERED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_COMPONENT_ALREADY_REGISTERED)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_LIST_CANT_ACCESS_DATA",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_LIST_CANT_ACCESS_DATA)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_METHOD_PTR_INVALID",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_METHOD_PTR_INVALID)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_METHOD_INVALID_PARAM_LIST",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_METHOD_INVALID_PARAM_LIST)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_SWIG_ERROR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_SWIG_ERROR)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_INVALID_INPUT_PARAMETER",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_INVALID_INPUT_PARAMETER)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_COMPONENT_NO_CALLBACK_REGISTERED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_COMPONENT_NO_CALLBACK_REGISTERED)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_INPUT_BUFFER_TOO_SMALL",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_INPUT_BUFFER_TOO_SMALL)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_WRONG_PARAM_COUNT",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_WRONG_PARAM_COUNT)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_UNSUPPORTED_OPERATION",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_UNSUPPORTED_OPERATION)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_CANT_SERIALIZE_DATA",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_CANT_SERIALIZE_DATA)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_INVALID_FILE_CONTENT",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_INVALID_FILE_CONTENT)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_CANT_ALLOCATE_LIST",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_CANT_ALLOCATE_LIST)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_CANT_REGISTER_COMPONENT",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_CANT_REGISTER_COMPONENT)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_PROP_VALIDATION_FAILED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_PROP_VALIDATION_FAILED)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_LAST_VALID_ERROR_CODE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_LAST_VALID_ERROR_CODE)));
  SWIG_Python_SetConstant(d, "sfDefault",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfDefault)));
  SWIG_Python_SetConstant(d, "sfNative",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfNative)));
  SWIG_Python_SetConstant(d, "sfRaw",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfRaw)));
  SWIG_Python_SetConstant(d, "sfVolatile",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfVolatile)));
  SWIG_Python_SetConstant(d, "sfProcessPropTranslationDict",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfProcessPropTranslationDict)));
  SWIG_Python_SetConstant(d, "sfCreateMissingEntries",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfCreateMissingEntries)));
  SWIG_Python_SetConstant(d, "sfProcessReadOnlyComponents",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfProcessReadOnlyComponents)));
  SWIG_Python_SetConstant(d, "sfIgnorePropData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfIgnorePropData)));
  SWIG_Python_SetConstant(d, "sfProcessDocString",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfProcessDocString)));
  SWIG_Python_SetConstant(d, "sfProcessPropConstantsDict",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfProcessPropConstantsDict)));
  SWIG_Python_SetConstant(d, "sfProcessInheritance",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfProcessInheritance)));
  SWIG_Python_SetConstant(d, "sfIgnoreBasicData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfIgnoreBasicData)));
  SWIG_Python_SetConstant(d, "sfIgnoreInvisible",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfIgnoreInvisible)));
  SWIG_Python_SetConstant(d, "sfFile",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfFile)));
  SWIG_Python_SetConstant(d, "sfProcessDisplayName",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfProcessDisplayName)));
  SWIG_Python_SetConstant(d, "sfRAM",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfRAM)));
  SWIG_Python_SetConstant(d, "sfDontProcessDefault",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfDontProcessDefault)));
  SWIG_Python_SetConstant(d, "sfProcessGenICamSequencerData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfProcessGenICamSequencerData)));
  SWIG_Python_SetConstant(d, "sfProcessGenICamUserSetData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfProcessGenICamUserSetData)));
  SWIG_Python_SetConstant(d, "slNative",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::slNative)));
  SWIG_Python_SetConstant(d, "slNative_Raw",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::slNative_Raw)));
  SWIG_Python_SetConstant(d, "slFile",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::slFile)));
  SWIG_Python_SetConstant(d, "slRAM",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::slRAM)));
  SWIG_Python_SetConstant(d, "sGlobal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sGlobal)));
  SWIG_Python_SetConstant(d, "sUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sUser)));
  SWIG_Python_SetConstant(d, "ibpfRaw",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfRaw)));
  SWIG_Python_SetConstant(d, "ibpfMono8",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfMono8)));
  SWIG_Python_SetConstant(d, "ibpfMono16",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfMono16)));
  SWIG_Python_SetConstant(d, "ibpfRGBx888Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfRGBx888Packed)));
  SWIG_Python_SetConstant(d, "ibpfYUV422Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV422Packed)));
  SWIG_Python_SetConstant(d, "ibpfRGBx888Planar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfRGBx888Planar)));
  SWIG_Python_SetConstant(d, "ibpfMono10",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfMono10)));
  SWIG_Python_SetConstant(d, "ibpfMono12",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfMono12)));
  SWIG_Python_SetConstant(d, "ibpfMono14",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfMono14)));
  SWIG_Python_SetConstant(d, "ibpfRGB888Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfRGB888Packed)));
  SWIG_Python_SetConstant(d, "ibpfYUV444Planar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV444Planar)));
  SWIG_Python_SetConstant(d, "ibpfMono32",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfMono32)));
  SWIG_Python_SetConstant(d, "ibpfYUV422Planar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV422Planar)));
  SWIG_Python_SetConstant(d, "ibpfRGB101010Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfRGB101010Packed)));
  SWIG_Python_SetConstant(d, "ibpfRGB121212Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfRGB121212Packed)));
  SWIG_Python_SetConstant(d, "ibpfRGB141414Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfRGB141414Packed)));
  SWIG_Python_SetConstant(d, "ibpfRGB161616Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfRGB161616Packed)));
  SWIG_Python_SetConstant(d, "ibpfYUV422_UYVYPacked",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV422_UYVYPacked)));
  SWIG_Python_SetConstant(d, "ibpfMono12Packed_V2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfMono12Packed_V2)));
  SWIG_Python_SetConstant(d, "ibpfYUV422_10Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV422_10Packed)));
  SWIG_Python_SetConstant(d, "ibpfYUV422_UYVY_10Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV422_UYVY_10Packed)));
  SWIG_Python_SetConstant(d, "ibpfBGR888Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfBGR888Packed)));
  SWIG_Python_SetConstant(d, "ibpfBGR101010Packed_V2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfBGR101010Packed_V2)));
  SWIG_Python_SetConstant(d, "ibpfYUV444_UYVPacked",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV444_UYVPacked)));
  SWIG_Python_SetConstant(d, "ibpfYUV444_UYV_10Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV444_UYV_10Packed)));
  SWIG_Python_SetConstant(d, "ibpfYUV444Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV444Packed)));
  SWIG_Python_SetConstant(d, "ibpfYUV444_10Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV444_10Packed)));
  SWIG_Python_SetConstant(d, "ibpfMono12Packed_V1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfMono12Packed_V1)));
  SWIG_Python_SetConstant(d, "ibpfYUV411_UYYVYY_Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfYUV411_UYYVYY_Packed)));
  SWIG_Python_SetConstant(d, "ibpfRGB888Planar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfRGB888Planar)));
  SWIG_Python_SetConstant(d, "ibpfAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibpfAuto)));
  SWIG_Python_SetConstant(d, "MVIMPACT_ACQUIRE_MAJOR_VERSION",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "MVIMPACT_ACQUIRE_MINOR_VERSION",SWIG_From_int(static_cast< int >(50)));
  SWIG_Python_SetConstant(d, "MVIMPACT_ACQUIRE_RELEASE_VERSION",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "MVIMPACT_ACQUIRE_BUILD_VERSION",SWIG_From_int(static_cast< int >(3768)));
  SWIG_Python_SetConstant(d, "MVIMPACT_ACQUIRE_VERSION_STRING",SWIG_FromCharPtr("2.50.1.3768"));
  SWIG_Python_SetConstant(d, "afAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::afAuto)));
  SWIG_Python_SetConstant(d, "afOdd",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::afOdd)));
  SWIG_Python_SetConstant(d, "afEven",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::afEven)));
  SWIG_Python_SetConstant(d, "afAny",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::afAny)));
  SWIG_Python_SetConstant(d, "amContinuous",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::amContinuous)));
  SWIG_Python_SetConstant(d, "amMultiFrame",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::amMultiFrame)));
  SWIG_Python_SetConstant(d, "amSingleFrame",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::amSingleFrame)));
  SWIG_Python_SetConstant(d, "assbDefault",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::assbDefault)));
  SWIG_Python_SetConstant(d, "assbUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::assbUser)));
  SWIG_Python_SetConstant(d, "amCentered",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::amCentered)));
  SWIG_Python_SetConstant(d, "amFull",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::amFull)));
  SWIG_Python_SetConstant(d, "amUseAoi",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::amUseAoi)));
  SWIG_Python_SetConstant(d, "acsSlow",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::acsSlow)));
  SWIG_Python_SetConstant(d, "acsMedium",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::acsMedium)));
  SWIG_Python_SetConstant(d, "acsFast",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::acsFast)));
  SWIG_Python_SetConstant(d, "acsUserDefined",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::acsUserDefined)));
  SWIG_Python_SetConstant(d, "acmStandard",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::acmStandard)));
  SWIG_Python_SetConstant(d, "acmDeviceSpecific",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::acmDeviceSpecific)));
  SWIG_Python_SetConstant(d, "aecOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::aecOff)));
  SWIG_Python_SetConstant(d, "aecOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::aecOn)));
  SWIG_Python_SetConstant(d, "agcOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::agcOff)));
  SWIG_Python_SetConstant(d, "agcOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::agcOn)));
  SWIG_Python_SetConstant(d, "aocOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::aocOff)));
  SWIG_Python_SetConstant(d, "aocOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::aocOn)));
  SWIG_Python_SetConstant(d, "bcmLinearInterpolation",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bcmLinearInterpolation)));
  SWIG_Python_SetConstant(d, "bcmAdaptiveEdgeSensing",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bcmAdaptiveEdgeSensing)));
  SWIG_Python_SetConstant(d, "bcmAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bcmAuto)));
  SWIG_Python_SetConstant(d, "bcmPacked",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bcmPacked)));
  SWIG_Python_SetConstant(d, "bcmLinearPacked",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bcmLinearPacked)));
  SWIG_Python_SetConstant(d, "bcmAdaptiveEdgeSensingPlus",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bcmAdaptiveEdgeSensingPlus)));
  SWIG_Python_SetConstant(d, "bcmAdaptiveHomogeneityDirected",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bcmAdaptiveHomogeneityDirected)));
  SWIG_Python_SetConstant(d, "bwbrUnknown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bwbrUnknown)));
  SWIG_Python_SetConstant(d, "bwbrOK",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bwbrOK)));
  SWIG_Python_SetConstant(d, "bwbrErrorUnknown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bwbrErrorUnknown)));
  SWIG_Python_SetConstant(d, "bwbrErrorTooDark",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bwbrErrorTooDark)));
  SWIG_Python_SetConstant(d, "bwbrErrorTooBright",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bwbrErrorTooBright)));
  SWIG_Python_SetConstant(d, "bfdit2V",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfdit2V)));
  SWIG_Python_SetConstant(d, "bfdit10V",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfdit10V)));
  SWIG_Python_SetConstant(d, "bffmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bffmOff)));
  SWIG_Python_SetConstant(d, "bffm64B",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bffm64B)));
  SWIG_Python_SetConstant(d, "bffm512B",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bffm512B)));
  SWIG_Python_SetConstant(d, "bfiscNone",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscNone)));
  SWIG_Python_SetConstant(d, "bfiscExposure",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscExposure)));
  SWIG_Python_SetConstant(d, "bfiscExposureAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscExposureAuto)));
  SWIG_Python_SetConstant(d, "bfiscGain",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscGain)));
  SWIG_Python_SetConstant(d, "bfiscGainAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscGainAuto)));
  SWIG_Python_SetConstant(d, "bfiscOffset",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscOffset)));
  SWIG_Python_SetConstant(d, "bfiscOffsetAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscOffsetAuto)));
  SWIG_Python_SetConstant(d, "bfiscBinning",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscBinning)));
  SWIG_Python_SetConstant(d, "bfiscTrigger",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscTrigger)));
  SWIG_Python_SetConstant(d, "bfiscFlash",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscFlash)));
  SWIG_Python_SetConstant(d, "bfiscLineTrigger",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscLineTrigger)));
  SWIG_Python_SetConstant(d, "bfiscShadingCorrection",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscShadingCorrection)));
  SWIG_Python_SetConstant(d, "bfiscOverlappedExposure",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscOverlappedExposure)));
  SWIG_Python_SetConstant(d, "bfiscFrameDelay",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscFrameDelay)));
  SWIG_Python_SetConstant(d, "bfiscLineDelay",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscLineDelay)));
  SWIG_Python_SetConstant(d, "bfiscAutoControlAOI",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscAutoControlAOI)));
  SWIG_Python_SetConstant(d, "bfiscAutoControlSpeed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscAutoControlSpeed)));
  SWIG_Python_SetConstant(d, "bfiscAutoControlDelay",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscAutoControlDelay)));
  SWIG_Python_SetConstant(d, "bfiscTemperatureSensor",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfiscTemperatureSensor)));
  SWIG_Python_SetConstant(d, "bfoablFastest",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfoablFastest)));
  SWIG_Python_SetConstant(d, "bfoablVeryFast",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfoablVeryFast)));
  SWIG_Python_SetConstant(d, "bfoablFast",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfoablFast)));
  SWIG_Python_SetConstant(d, "bfoablMedium",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfoablMedium)));
  SWIG_Python_SetConstant(d, "bfoablSlow",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfoablSlow)));
  SWIG_Python_SetConstant(d, "bfoablVerySlow",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfoablVerySlow)));
  SWIG_Python_SetConstant(d, "bfoablSlowest",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfoablSlowest)));
  SWIG_Python_SetConstant(d, "bfstStandard",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfstStandard)));
  SWIG_Python_SetConstant(d, "bfstFastLineSkip",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfstFastLineSkip)));
  SWIG_Python_SetConstant(d, "bfstLowSmearLineSkip",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfstLowSmearLineSkip)));
  SWIG_Python_SetConstant(d, "bfts16KB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfts16KB)));
  SWIG_Python_SetConstant(d, "bfts32KB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfts32KB)));
  SWIG_Python_SetConstant(d, "bfts64KB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfts64KB)));
  SWIG_Python_SetConstant(d, "bfts128KB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfts128KB)));
  SWIG_Python_SetConstant(d, "bfts256KB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfts256KB)));
  SWIG_Python_SetConstant(d, "bfts512KB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfts512KB)));
  SWIG_Python_SetConstant(d, "bfts1024KB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfts1024KB)));
  SWIG_Python_SetConstant(d, "bfts2048KB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bfts2048KB)));
  SWIG_Python_SetConstant(d, "bFalse",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bFalse)));
  SWIG_Python_SetConstant(d, "bTrue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bTrue)));
  SWIG_Python_SetConstant(d, "camFull",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::camFull)));
  SWIG_Python_SetConstant(d, "camUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::camUser)));
  SWIG_Python_SetConstant(d, "cbmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmOff)));
  SWIG_Python_SetConstant(d, "cbmBinningH",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinningH)));
  SWIG_Python_SetConstant(d, "cbmBinningV",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinningV)));
  SWIG_Python_SetConstant(d, "cbmBinningHV",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinningHV)));
  SWIG_Python_SetConstant(d, "cbmBinning3H",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinning3H)));
  SWIG_Python_SetConstant(d, "cbmBinning3V",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinning3V)));
  SWIG_Python_SetConstant(d, "cbmBinning3H3V",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinning3H3V)));
  SWIG_Python_SetConstant(d, "cbmBinningHAvg",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinningHAvg)));
  SWIG_Python_SetConstant(d, "cbmBinningVAvg",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinningVAvg)));
  SWIG_Python_SetConstant(d, "cbmBinningHVAvg",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinningHVAvg)));
  SWIG_Python_SetConstant(d, "cbmBinning3HAvg",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinning3HAvg)));
  SWIG_Python_SetConstant(d, "cbmBinning3VAvg",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinning3VAvg)));
  SWIG_Python_SetConstant(d, "cbmBinning3H3VAvg",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmBinning3H3VAvg)));
  SWIG_Python_SetConstant(d, "cbmDroppingH",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmDroppingH)));
  SWIG_Python_SetConstant(d, "cbmDroppingV",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmDroppingV)));
  SWIG_Python_SetConstant(d, "cbmDroppingHV",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmDroppingHV)));
  SWIG_Python_SetConstant(d, "cbmDropping3H",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmDropping3H)));
  SWIG_Python_SetConstant(d, "cbmDropping3V",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmDropping3V)));
  SWIG_Python_SetConstant(d, "cbmDropping3H3V",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cbmDropping3H3V)));
  SWIG_Python_SetConstant(d, "cdfUnknown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cdfUnknown)));
  SWIG_Python_SetConstant(d, "cdfMono",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cdfMono)));
  SWIG_Python_SetConstant(d, "cdfBayer",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cdfBayer)));
  SWIG_Python_SetConstant(d, "cdfBayerPacked",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cdfBayerPacked)));
  SWIG_Python_SetConstant(d, "cdfRGB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cdfRGB)));
  SWIG_Python_SetConstant(d, "cdfYUV",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cdfYUV)));
  SWIG_Python_SetConstant(d, "cemStandard",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cemStandard)));
  SWIG_Python_SetConstant(d, "cemOverlapped",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cemOverlapped)));
  SWIG_Python_SetConstant(d, "cemNoShutter",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cemNoShutter)));
  SWIG_Python_SetConstant(d, "ceseNo",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ceseNo)));
  SWIG_Python_SetConstant(d, "ceseFallingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ceseFallingEdge)));
  SWIG_Python_SetConstant(d, "ceseRisingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ceseRisingEdge)));
  SWIG_Python_SetConstant(d, "cesoAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cesoAuto)));
  SWIG_Python_SetConstant(d, "cesoRed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cesoRed)));
  SWIG_Python_SetConstant(d, "cesoGreen",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cesoGreen)));
  SWIG_Python_SetConstant(d, "cesoBlue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cesoBlue)));
  SWIG_Python_SetConstant(d, "cesoExtern",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cesoExtern)));
  SWIG_Python_SetConstant(d, "cfmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfmOff)));
  SWIG_Python_SetConstant(d, "cfmDigout0",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfmDigout0)));
  SWIG_Python_SetConstant(d, "cfmDigout1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfmDigout1)));
  SWIG_Python_SetConstant(d, "cftStandard",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cftStandard)));
  SWIG_Python_SetConstant(d, "cftRollingShutterFlash",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cftRollingShutterFlash)));
  SWIG_Python_SetConstant(d, "cftVSync",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cftVSync)));
  SWIG_Python_SetConstant(d, "cHDRmFixed0",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cHDRmFixed0)));
  SWIG_Python_SetConstant(d, "cHDRmFixed1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cHDRmFixed1)));
  SWIG_Python_SetConstant(d, "cHDRmFixed2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cHDRmFixed2)));
  SWIG_Python_SetConstant(d, "cHDRmFixed3",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cHDRmFixed3)));
  SWIG_Python_SetConstant(d, "cHDRmFixed4",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cHDRmFixed4)));
  SWIG_Python_SetConstant(d, "cHDRmFixed5",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cHDRmFixed5)));
  SWIG_Python_SetConstant(d, "cHDRmFixed6",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cHDRmFixed6)));
  SWIG_Python_SetConstant(d, "cHDRmUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cHDRmUser)));
  SWIG_Python_SetConstant(d, "citNone",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::citNone)));
  SWIG_Python_SetConstant(d, "citInterlaced",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::citInterlaced)));
  SWIG_Python_SetConstant(d, "citInvertedInterlaced",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::citInvertedInterlaced)));
  SWIG_Python_SetConstant(d, "cldvmActive",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cldvmActive)));
  SWIG_Python_SetConstant(d, "cldvmInactive",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cldvmInactive)));
  SWIG_Python_SetConstant(d, "coUndefined",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coUndefined)));
  SWIG_Python_SetConstant(d, "coAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coAuto)));
  SWIG_Python_SetConstant(d, "coComposite",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coComposite)));
  SWIG_Python_SetConstant(d, "coBase",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coBase)));
  SWIG_Python_SetConstant(d, "coDigital",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coDigital)));
  SWIG_Python_SetConstant(d, "coSVideo",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coSVideo)));
  SWIG_Python_SetConstant(d, "coMedium",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coMedium)));
  SWIG_Python_SetConstant(d, "coRGB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coRGB)));
  SWIG_Python_SetConstant(d, "co2xComposite",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::co2xComposite)));
  SWIG_Python_SetConstant(d, "co3xComposite",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::co3xComposite)));
  SWIG_Python_SetConstant(d, "co4xComposite",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::co4xComposite)));
  SWIG_Python_SetConstant(d, "coFull",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coFull)));
  SWIG_Python_SetConstant(d, "coSDSDI",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coSDSDI)));
  SWIG_Python_SetConstant(d, "coHDSDI",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::coHDSDI)));
  SWIG_Python_SetConstant(d, "co3GSDI",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::co3GSDI)));
  SWIG_Python_SetConstant(d, "cpcStandard",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpcStandard)));
  SWIG_Python_SetConstant(d, "cpcHighSpeed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpcHighSpeed)));
  SWIG_Python_SetConstant(d, "cpc6000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc6000KHz)));
  SWIG_Python_SetConstant(d, "cpc8000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc8000KHz)));
  SWIG_Python_SetConstant(d, "cpc10000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc10000KHz)));
  SWIG_Python_SetConstant(d, "cpc12000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc12000KHz)));
  SWIG_Python_SetConstant(d, "cpc13500KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc13500KHz)));
  SWIG_Python_SetConstant(d, "cpc20000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc20000KHz)));
  SWIG_Python_SetConstant(d, "cpc24000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc24000KHz)));
  SWIG_Python_SetConstant(d, "cpc24540KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc24540KHz)));
  SWIG_Python_SetConstant(d, "cpc27000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc27000KHz)));
  SWIG_Python_SetConstant(d, "cpc32000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc32000KHz)));
  SWIG_Python_SetConstant(d, "cpc37600KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc37600KHz)));
  SWIG_Python_SetConstant(d, "cpc40000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc40000KHz)));
  SWIG_Python_SetConstant(d, "cpc50000KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc50000KHz)));
  SWIG_Python_SetConstant(d, "cpc57600KHz",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpc57600KHz)));
  SWIG_Python_SetConstant(d, "csmArea",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::csmArea)));
  SWIG_Python_SetConstant(d, "csmLine",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::csmLine)));
  SWIG_Python_SetConstant(d, "cspbr9600",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cspbr9600)));
  SWIG_Python_SetConstant(d, "cspbr19200",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cspbr19200)));
  SWIG_Python_SetConstant(d, "cspbr38400",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cspbr38400)));
  SWIG_Python_SetConstant(d, "cspbr57600",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cspbr57600)));
  SWIG_Python_SetConstant(d, "cspbr115200",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cspbr115200)));
  SWIG_Python_SetConstant(d, "cspbr230400",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cspbr230400)));
  SWIG_Python_SetConstant(d, "cspbr460800",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cspbr460800)));
  SWIG_Python_SetConstant(d, "cspbr921600",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cspbr921600)));
  SWIG_Python_SetConstant(d, "csmFrameShutter",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::csmFrameShutter)));
  SWIG_Python_SetConstant(d, "csmElectronicRollingShutter",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::csmElectronicRollingShutter)));
  SWIG_Python_SetConstant(d, "csmGlobalResetRelease",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::csmGlobalResetRelease)));
  SWIG_Python_SetConstant(d, "csmFrameShutterWithFastCenterReadout",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::csmFrameShutterWithFastCenterReadout)));
  SWIG_Python_SetConstant(d, "cltxg1X",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg1X)));
  SWIG_Python_SetConstant(d, "cltxg1X2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg1X2)));
  SWIG_Python_SetConstant(d, "cltxg2X",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg2X)));
  SWIG_Python_SetConstant(d, "cltxg2XE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg2XE)));
  SWIG_Python_SetConstant(d, "cltxg2XM",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg2XM)));
  SWIG_Python_SetConstant(d, "cltxg1X3",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg1X3)));
  SWIG_Python_SetConstant(d, "cltxg3X",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg3X)));
  SWIG_Python_SetConstant(d, "cltxg1X4",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg1X4)));
  SWIG_Python_SetConstant(d, "cltxg4X",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg4X)));
  SWIG_Python_SetConstant(d, "cltxg2X2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg2X2)));
  SWIG_Python_SetConstant(d, "cltxg2X2E",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg2X2E)));
  SWIG_Python_SetConstant(d, "cltxg2X2M",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg2X2M)));
  SWIG_Python_SetConstant(d, "cltxg4XE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg4XE)));
  SWIG_Python_SetConstant(d, "cltxg1X8",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg1X8)));
  SWIG_Python_SetConstant(d, "cltxg8X",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg8X)));
  SWIG_Python_SetConstant(d, "cltxg4X2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg4X2)));
  SWIG_Python_SetConstant(d, "cltxg4X2E",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltxg4X2E)));
  SWIG_Python_SetConstant(d, "cltyg1Y",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltyg1Y)));
  SWIG_Python_SetConstant(d, "cltyg1Y2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltyg1Y2)));
  SWIG_Python_SetConstant(d, "cltyg2YE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cltyg2YE)));
  SWIG_Python_SetConstant(d, "ctmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmOff)));
  SWIG_Python_SetConstant(d, "ctmGreyRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmGreyRamp)));
  SWIG_Python_SetConstant(d, "ctmMovingColor",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmMovingColor)));
  SWIG_Python_SetConstant(d, "ctmWBTest",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmWBTest)));
  SWIG_Python_SetConstant(d, "ctmContinuous",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmContinuous)));
  SWIG_Python_SetConstant(d, "ctmOnDemand",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmOnDemand)));
  SWIG_Python_SetConstant(d, "ctmOnLowLevel",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmOnLowLevel)));
  SWIG_Python_SetConstant(d, "ctmOnHighLevel",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmOnHighLevel)));
  SWIG_Python_SetConstant(d, "ctmOnFallingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmOnFallingEdge)));
  SWIG_Python_SetConstant(d, "ctmOnRisingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmOnRisingEdge)));
  SWIG_Python_SetConstant(d, "ctmOnHighExpose",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmOnHighExpose)));
  SWIG_Python_SetConstant(d, "ctmOnLowExpose",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmOnLowExpose)));
  SWIG_Python_SetConstant(d, "ctmOnAnyEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmOnAnyEdge)));
  SWIG_Python_SetConstant(d, "ctmFramerateControlled",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctmFramerateControlled)));
  SWIG_Python_SetConstant(d, "ctsDigIn0",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctsDigIn0)));
  SWIG_Python_SetConstant(d, "ctsDigIn1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctsDigIn1)));
  SWIG_Python_SetConstant(d, "ctsRTCtrl",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctsRTCtrl)));
  SWIG_Python_SetConstant(d, "ctsDigOut0",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctsDigOut0)));
  SWIG_Python_SetConstant(d, "ctsDigOut1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctsDigOut1)));
  SWIG_Python_SetConstant(d, "ctsDigOut2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctsDigOut2)));
  SWIG_Python_SetConstant(d, "ctsDigOut3",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctsDigOut3)));
  SWIG_Python_SetConstant(d, "csmVertical",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::csmVertical)));
  SWIG_Python_SetConstant(d, "csmHorizontal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::csmHorizontal)));
  SWIG_Python_SetConstant(d, "csmExtractSingle",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::csmExtractSingle)));
  SWIG_Python_SetConstant(d, "ecmAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ecmAuto)));
  SWIG_Python_SetConstant(d, "ecmUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ecmUser)));
  SWIG_Python_SetConstant(d, "cticmmUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cticmmUser)));
  SWIG_Python_SetConstant(d, "cticmmDeviceSpecific",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cticmmDeviceSpecific)));
  SWIG_Python_SetConstant(d, "ctocmmUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctocmmUser)));
  SWIG_Python_SetConstant(d, "ctocmmXYZToAdobeRGB_D50",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctocmmXYZToAdobeRGB_D50)));
  SWIG_Python_SetConstant(d, "ctocmmXYZTosRGB_D50",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctocmmXYZTosRGB_D50)));
  SWIG_Python_SetConstant(d, "ctocmmXYZToWideGamutRGB_D50",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctocmmXYZToWideGamutRGB_D50)));
  SWIG_Python_SetConstant(d, "ctocmmXYZToAdobeRGB_D65",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctocmmXYZToAdobeRGB_D65)));
  SWIG_Python_SetConstant(d, "ctocmmXYZTosRGB_D65",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ctocmmXYZTosRGB_D65)));
  SWIG_Python_SetConstant(d, "cpmAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpmAuto)));
  SWIG_Python_SetConstant(d, "cpmRaw",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpmRaw)));
  SWIG_Python_SetConstant(d, "cpmBayer",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpmBayer)));
  SWIG_Python_SetConstant(d, "cpmBayerToMono",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpmBayerToMono)));
  SWIG_Python_SetConstant(d, "cpmRawToPlanes",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cpmRawToPlanes)));
  SWIG_Python_SetConstant(d, "dcfmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcfmOff)));
  SWIG_Python_SetConstant(d, "dcfmOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcfmOn)));
  SWIG_Python_SetConstant(d, "dcfmCalibrateDarkCurrent",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcfmCalibrateDarkCurrent)));
  SWIG_Python_SetConstant(d, "dcfmTransmitCorrectionImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcfmTransmitCorrectionImage)));
  SWIG_Python_SetConstant(d, "dpfmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpfmOff)));
  SWIG_Python_SetConstant(d, "dpfm3x1Average",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpfm3x1Average)));
  SWIG_Python_SetConstant(d, "dpfm3x3Median",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpfm3x3Median)));
  SWIG_Python_SetConstant(d, "dpfmResetCalibration",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpfmResetCalibration)));
  SWIG_Python_SetConstant(d, "dpfmCalibrateLeakyPixel",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpfmCalibrateLeakyPixel)));
  SWIG_Python_SetConstant(d, "dpfmCalibrateColdPixel",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpfmCalibrateColdPixel)));
  SWIG_Python_SetConstant(d, "dpfmCalibrateHotPixel",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpfmCalibrateHotPixel)));
  SWIG_Python_SetConstant(d, "dpfmCalibrateHotAndColdPixel",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpfmCalibrateHotAndColdPixel)));
  SWIG_Python_SetConstant(d, "dpfmReplaceDefectivePixelAfter3x3Filter",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpfmReplaceDefectivePixelAfter3x3Filter)));
  SWIG_Python_SetConstant(d, "damUnknown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::damUnknown)));
  SWIG_Python_SetConstant(d, "damNone",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::damNone)));
  SWIG_Python_SetConstant(d, "damRead",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::damRead)));
  SWIG_Python_SetConstant(d, "damControl",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::damControl)));
  SWIG_Python_SetConstant(d, "damExclusive",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::damExclusive)));
  SWIG_Python_SetConstant(d, "daoOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoOff)));
  SWIG_Python_SetConstant(d, "daoLowLight",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoLowLight)));
  SWIG_Python_SetConstant(d, "daoEmbeddedImageInfo",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoEmbeddedImageInfo)));
  SWIG_Python_SetConstant(d, "daoImageAverage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoImageAverage)));
  SWIG_Python_SetConstant(d, "daoPipelinedGainExposeControl",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoPipelinedGainExposeControl)));
  SWIG_Python_SetConstant(d, "daoOnDemandTriggerPreShot",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoOnDemandTriggerPreShot)));
  SWIG_Python_SetConstant(d, "daoLowFrameRateOptimization",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoLowFrameRateOptimization)));
  SWIG_Python_SetConstant(d, "daoEnablePerChannelOffsetCorrection",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoEnablePerChannelOffsetCorrection)));
  SWIG_Python_SetConstant(d, "daoUseRawSensorGain",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoUseRawSensorGain)));
  SWIG_Python_SetConstant(d, "daoTriggerSensorColumnCalibration",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::daoTriggerSensorColumnCalibration)));
  SWIG_Python_SetConstant(d, "danpsmHighToLow",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::danpsmHighToLow)));
  SWIG_Python_SetConstant(d, "danpsmLowToHigh",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::danpsmLowToHigh)));
  SWIG_Python_SetConstant(d, "dcNone",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcNone)));
  SWIG_Python_SetConstant(d, "dcHotplugable",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcHotplugable)));
  SWIG_Python_SetConstant(d, "dcSelectableVideoInputs",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcSelectableVideoInputs)));
  SWIG_Python_SetConstant(d, "dcNonVolatileUserMemory",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcNonVolatileUserMemory)));
  SWIG_Python_SetConstant(d, "dcCameraDescriptionSupport",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcCameraDescriptionSupport)));
  SWIG_Python_SetConstant(d, "dcEventSupport",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcEventSupport)));
  SWIG_Python_SetConstant(d, "dcGeneric",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcGeneric)));
  SWIG_Python_SetConstant(d, "dcCamera",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcCamera)));
  SWIG_Python_SetConstant(d, "dcIntelligentCamera",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcIntelligentCamera)));
  SWIG_Python_SetConstant(d, "dcFrameGrabber",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dcFrameGrabber)));
  SWIG_Python_SetConstant(d, "dc3DCamera",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dc3DCamera)));
  SWIG_Python_SetConstant(d, "ddomManual",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomManual)));
  SWIG_Python_SetConstant(d, "ddomPulse",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomPulse)));
  SWIG_Python_SetConstant(d, "ddomUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomUser)));
  SWIG_Python_SetConstant(d, "ddomExposureActive",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomExposureActive)));
  SWIG_Python_SetConstant(d, "ddomDigitalSignalPassThrough",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomDigitalSignalPassThrough)));
  SWIG_Python_SetConstant(d, "ddomDigitalSignalPassThroughInv",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomDigitalSignalPassThroughInv)));
  SWIG_Python_SetConstant(d, "ddomInternalVD",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomInternalVD)));
  SWIG_Python_SetConstant(d, "ddomRealTimeController",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomRealTimeController)));
  SWIG_Python_SetConstant(d, "ddomExposureAndAcquisitionActive",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomExposureAndAcquisitionActive)));
  SWIG_Python_SetConstant(d, "ddomTemperatureOutOfRange",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ddomTemperatureOutOfRange)));
  SWIG_Python_SetConstant(d, "ditImmediately",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ditImmediately)));
  SWIG_Python_SetConstant(d, "ditAfterDigOutSignals",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ditAfterDigOutSignals)));
  SWIG_Python_SetConstant(d, "dilDeviceSpecific",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dilDeviceSpecific)));
  SWIG_Python_SetConstant(d, "dilGenICam",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dilGenICam)));
  SWIG_Python_SetConstant(d, "dlsAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dlsAuto)));
  SWIG_Python_SetConstant(d, "dlsNoLoad",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dlsNoLoad)));
  SWIG_Python_SetConstant(d, "dpmOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpmOn)));
  SWIG_Python_SetConstant(d, "dpmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dpmOff)));
  SWIG_Python_SetConstant(d, "dsrmAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsrmAuto)));
  SWIG_Python_SetConstant(d, "dsrmUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsrmUser)));
  SWIG_Python_SetConstant(d, "dsoseFrame",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseFrame)));
  SWIG_Python_SetConstant(d, "dsoseTrigger",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseTrigger)));
  SWIG_Python_SetConstant(d, "dsoseFrameAfterTrigger",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseFrameAfterTrigger)));
  SWIG_Python_SetConstant(d, "dsoseSyncInRisingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseSyncInRisingEdge)));
  SWIG_Python_SetConstant(d, "dsoseSyncInFallingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseSyncInFallingEdge)));
  SWIG_Python_SetConstant(d, "dsoseSyncInPassThrough",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseSyncInPassThrough)));
  SWIG_Python_SetConstant(d, "dsoseSyncInPassThroughInv",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseSyncInPassThroughInv)));
  SWIG_Python_SetConstant(d, "dsosePeriodically",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsosePeriodically)));
  SWIG_Python_SetConstant(d, "dsoseTriggerInPassThrough",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseTriggerInPassThrough)));
  SWIG_Python_SetConstant(d, "dsoseTriggerInPassThroughInv",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseTriggerInPassThroughInv)));
  SWIG_Python_SetConstant(d, "dsoseFVALPassThrough",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseFVALPassThrough)));
  SWIG_Python_SetConstant(d, "dsoseFVALPassThroughInv",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseFVALPassThroughInv)));
  SWIG_Python_SetConstant(d, "dsoseFVALRisingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsoseFVALRisingEdge)));
  SWIG_Python_SetConstant(d, "dsAbsent",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsAbsent)));
  SWIG_Python_SetConstant(d, "dsPresent",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsPresent)));
  SWIG_Python_SetConstant(d, "dsInitializing",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsInitializing)));
  SWIG_Python_SetConstant(d, "dsUnreachable",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsUnreachable)));
  SWIG_Python_SetConstant(d, "dsPowerDown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsPowerDown)));
  SWIG_Python_SetConstant(d, "dsomOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsomOff)));
  SWIG_Python_SetConstant(d, "dsomNonInterlaced",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsomNonInterlaced)));
  SWIG_Python_SetConstant(d, "dsomInterlaced",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsomInterlaced)));
  SWIG_Python_SetConstant(d, "dtiStandard",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtiStandard)));
  SWIG_Python_SetConstant(d, "dtiAdvanced",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtiAdvanced)));
  SWIG_Python_SetConstant(d, "dtmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmOff)));
  SWIG_Python_SetConstant(d, "dtmOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmOn)));
  SWIG_Python_SetConstant(d, "dtmFallingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmFallingEdge)));
  SWIG_Python_SetConstant(d, "dtmRisingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmRisingEdge)));
  SWIG_Python_SetConstant(d, "dtmPeriodically",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmPeriodically)));
  SWIG_Python_SetConstant(d, "dtmOnDemand",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmOnDemand)));
  SWIG_Python_SetConstant(d, "dtmStartRisingStopFalling",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmStartRisingStopFalling)));
  SWIG_Python_SetConstant(d, "dtmStartFallingStopRising",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmStartFallingStopRising)));
  SWIG_Python_SetConstant(d, "dtmLevelHigh",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmLevelHigh)));
  SWIG_Python_SetConstant(d, "dtmLevelLow",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtmLevelLow)));
  SWIG_Python_SetConstant(d, "dtoOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtoOff)));
  SWIG_Python_SetConstant(d, "dtoReadOut",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtoReadOut)));
  SWIG_Python_SetConstant(d, "dtoPreviousFrame",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dtoPreviousFrame)));
  SWIG_Python_SetConstant(d, "digioOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::digioOff)));
  SWIG_Python_SetConstant(d, "digioOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::digioOn)));
  SWIG_Python_SetConstant(d, "digioIgnore",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::digioIgnore)));
  SWIG_Python_SetConstant(d, "digioKeep",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::digioKeep)));
  SWIG_Python_SetConstant(d, "diommFrequency_Hz_10ms",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::diommFrequency_Hz_10ms)));
  SWIG_Python_SetConstant(d, "diommFrequency_Hz_100ms",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::diommFrequency_Hz_100ms)));
  SWIG_Python_SetConstant(d, "diomsInput0",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::diomsInput0)));
  SWIG_Python_SetConstant(d, "diomsInput1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::diomsInput1)));
  SWIG_Python_SetConstant(d, "diomsInput2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::diomsInput2)));
  SWIG_Python_SetConstant(d, "diomsInput3",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::diomsInput3)));
  SWIG_Python_SetConstant(d, "docmSoftware",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::docmSoftware)));
  SWIG_Python_SetConstant(d, "docmRTC",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::docmRTC)));
  SWIG_Python_SetConstant(d, "dsNone",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsNone)));
  SWIG_Python_SetConstant(d, "dsSignal1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal1)));
  SWIG_Python_SetConstant(d, "dsSignal2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal2)));
  SWIG_Python_SetConstant(d, "dsSignal3",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal3)));
  SWIG_Python_SetConstant(d, "dsSignal4",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal4)));
  SWIG_Python_SetConstant(d, "dsSignal5",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal5)));
  SWIG_Python_SetConstant(d, "dsSignal6",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal6)));
  SWIG_Python_SetConstant(d, "dsSignal7",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal7)));
  SWIG_Python_SetConstant(d, "dsSignal8",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal8)));
  SWIG_Python_SetConstant(d, "dsSignal9",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal9)));
  SWIG_Python_SetConstant(d, "dsSignal10",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal10)));
  SWIG_Python_SetConstant(d, "dsSignal11",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal11)));
  SWIG_Python_SetConstant(d, "dsSignal12",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal12)));
  SWIG_Python_SetConstant(d, "dsSignal13",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal13)));
  SWIG_Python_SetConstant(d, "dsSignal14",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal14)));
  SWIG_Python_SetConstant(d, "dsSignal15",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal15)));
  SWIG_Python_SetConstant(d, "dsSignal16",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dsSignal16)));
  SWIG_Python_SetConstant(d, "DMR_NO_ERROR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_NO_ERROR)));
  SWIG_Python_SetConstant(d, "DMR_DEV_NOT_FOUND",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_DEV_NOT_FOUND)));
  SWIG_Python_SetConstant(d, "DMR_INIT_FAILED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_INIT_FAILED)));
  SWIG_Python_SetConstant(d, "DMR_DRV_ALREADY_IN_USE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_DRV_ALREADY_IN_USE)));
  SWIG_Python_SetConstant(d, "DMR_DEV_CANNOT_OPEN",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_DEV_CANNOT_OPEN)));
  SWIG_Python_SetConstant(d, "DMR_NOT_INITIALIZED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_NOT_INITIALIZED)));
  SWIG_Python_SetConstant(d, "DMR_DRV_CANNOT_OPEN",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_DRV_CANNOT_OPEN)));
  SWIG_Python_SetConstant(d, "DMR_DEV_REQUEST_QUEUE_EMPTY",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_DEV_REQUEST_QUEUE_EMPTY)));
  SWIG_Python_SetConstant(d, "DMR_DEV_REQUEST_CREATION_FAILED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_DEV_REQUEST_CREATION_FAILED)));
  SWIG_Python_SetConstant(d, "DMR_INVALID_PARAMETER",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_INVALID_PARAMETER)));
  SWIG_Python_SetConstant(d, "DMR_EXPORTED_SYMBOL_NOT_FOUND",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_EXPORTED_SYMBOL_NOT_FOUND)));
  SWIG_Python_SetConstant(d, "DEV_UNKNOWN_ERROR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_UNKNOWN_ERROR)));
  SWIG_Python_SetConstant(d, "DEV_HANDLE_INVALID",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_HANDLE_INVALID)));
  SWIG_Python_SetConstant(d, "DEV_INPUT_PARAM_INVALID",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID)));
  SWIG_Python_SetConstant(d, "DEV_WRONG_INPUT_PARAM_COUNT",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_WRONG_INPUT_PARAM_COUNT)));
  SWIG_Python_SetConstant(d, "DEV_CREATE_SETTING_FAILED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_CREATE_SETTING_FAILED)));
  SWIG_Python_SetConstant(d, "DEV_REQUEST_CANT_BE_UNLOCKED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_REQUEST_CANT_BE_UNLOCKED)));
  SWIG_Python_SetConstant(d, "DEV_INVALID_REQUEST_NUMBER",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_INVALID_REQUEST_NUMBER)));
  SWIG_Python_SetConstant(d, "DEV_LOCKED_REQUEST_IN_QUEUE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_LOCKED_REQUEST_IN_QUEUE)));
  SWIG_Python_SetConstant(d, "DEV_NO_FREE_REQUEST_AVAILABLE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_NO_FREE_REQUEST_AVAILABLE)));
  SWIG_Python_SetConstant(d, "DEV_WAIT_FOR_REQUEST_FAILED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_WAIT_FOR_REQUEST_FAILED)));
  SWIG_Python_SetConstant(d, "DEV_UNSUPPORTED_PARAMETER",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_UNSUPPORTED_PARAMETER)));
  SWIG_Python_SetConstant(d, "DEV_INVALID_RTC_NUMBER",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_INVALID_RTC_NUMBER)));
  SWIG_Python_SetConstant(d, "DMR_INTERNAL_ERROR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_INTERNAL_ERROR)));
  SWIG_Python_SetConstant(d, "DMR_INPUT_BUFFER_TOO_SMALL",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_INPUT_BUFFER_TOO_SMALL)));
  SWIG_Python_SetConstant(d, "DEV_INTERNAL_ERROR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_INTERNAL_ERROR)));
  SWIG_Python_SetConstant(d, "DMR_LIBRARY_NOT_FOUND",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_LIBRARY_NOT_FOUND)));
  SWIG_Python_SetConstant(d, "DMR_FUNCTION_NOT_IMPLEMENTED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_FUNCTION_NOT_IMPLEMENTED)));
  SWIG_Python_SetConstant(d, "DMR_FEATURE_NOT_AVAILABLE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE)));
  SWIG_Python_SetConstant(d, "DMR_EXECUTION_PROHIBITED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_EXECUTION_PROHIBITED)));
  SWIG_Python_SetConstant(d, "DMR_FILE_NOT_FOUND",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_FILE_NOT_FOUND)));
  SWIG_Python_SetConstant(d, "DMR_INVALID_LICENCE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_INVALID_LICENCE)));
  SWIG_Python_SetConstant(d, "DEV_SENSOR_TYPE_ERROR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_SENSOR_TYPE_ERROR)));
  SWIG_Python_SetConstant(d, "DMR_CAMERA_DESCRIPTION_INVALID",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_CAMERA_DESCRIPTION_INVALID)));
  SWIG_Python_SetConstant(d, "DMR_NEWER_LIBRARY_REQUIRED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_NEWER_LIBRARY_REQUIRED)));
  SWIG_Python_SetConstant(d, "DMR_TIMEOUT",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_TIMEOUT)));
  SWIG_Python_SetConstant(d, "DMR_WAIT_ABANDONED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_WAIT_ABANDONED)));
  SWIG_Python_SetConstant(d, "DMR_EXECUTION_FAILED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_EXECUTION_FAILED)));
  SWIG_Python_SetConstant(d, "DEV_REQUEST_ALREADY_IN_USE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_REQUEST_ALREADY_IN_USE)));
  SWIG_Python_SetConstant(d, "DEV_REQUEST_BUFFER_INVALID",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_REQUEST_BUFFER_INVALID)));
  SWIG_Python_SetConstant(d, "DEV_REQUEST_BUFFER_MISALIGNED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_REQUEST_BUFFER_MISALIGNED)));
  SWIG_Python_SetConstant(d, "DEV_ACCESS_DENIED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DEV_ACCESS_DENIED)));
  SWIG_Python_SetConstant(d, "DMR_PRELOAD_CHECK_FAILED",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_PRELOAD_CHECK_FAILED)));
  SWIG_Python_SetConstant(d, "DMR_CAMERA_DESCRIPTION_INVALID_PARAMETER",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_CAMERA_DESCRIPTION_INVALID_PARAMETER)));
  SWIG_Python_SetConstant(d, "DMR_FILE_ACCESS_ERROR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_FILE_ACCESS_ERROR)));
  SWIG_Python_SetConstant(d, "DMR_INVALID_QUEUE_SELECTION",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_INVALID_QUEUE_SELECTION)));
  SWIG_Python_SetConstant(d, "DMR_ACQUISITION_ENGINE_BUSY",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_ACQUISITION_ENGINE_BUSY)));
  SWIG_Python_SetConstant(d, "DMR_BUSY",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_BUSY)));
  SWIG_Python_SetConstant(d, "DMR_OUT_OF_MEMORY",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_OUT_OF_MEMORY)));
  SWIG_Python_SetConstant(d, "DMR_LAST_VALID_ERROR_CODE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::DMR_LAST_VALID_ERROR_CODE)));
  SWIG_Python_SetConstant(d, "efmAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::efmAuto)));
  SWIG_Python_SetConstant(d, "efmUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::efmUser)));
  SWIG_Python_SetConstant(d, "ffcmDefault",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ffcmDefault)));
  SWIG_Python_SetConstant(d, "ffcmBrightPreserving",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ffcmBrightPreserving)));
  SWIG_Python_SetConstant(d, "fffmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fffmOff)));
  SWIG_Python_SetConstant(d, "fffmOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fffmOn)));
  SWIG_Python_SetConstant(d, "fffmCalibrateFlatField",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fffmCalibrateFlatField)));
  SWIG_Python_SetConstant(d, "fffmTransmitCorrectionImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fffmTransmitCorrectionImage)));
  SWIG_Python_SetConstant(d, "fusErrorMessage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fusErrorMessage)));
  SWIG_Python_SetConstant(d, "fusUnzippingFirmwareArchive",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fusUnzippingFirmwareArchive)));
  SWIG_Python_SetConstant(d, "fusSavingUserSets",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fusSavingUserSets)));
  SWIG_Python_SetConstant(d, "fusErasingFlash",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fusErasingFlash)));
  SWIG_Python_SetConstant(d, "fusUpdatingBootProgrammer",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fusUpdatingBootProgrammer)));
  SWIG_Python_SetConstant(d, "fusUploadingFirmware",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fusUploadingFirmware)));
  SWIG_Python_SetConstant(d, "fusHardResetRequired",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fusHardResetRequired)));
  SWIG_Python_SetConstant(d, "fusRebootingDevice",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fusRebootingDevice)));
  SWIG_Python_SetConstant(d, "fusLoadingUserSets",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fusLoadingUserSets)));
  SWIG_Python_SetConstant(d, "fuaContinue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fuaContinue)));
  SWIG_Python_SetConstant(d, "fuaCancel",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::fuaCancel)));
  SWIG_Python_SetConstant(d, "urNoUpdatePerformed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urNoUpdatePerformed)));
  SWIG_Python_SetConstant(d, "urUpdateFW",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urUpdateFW)));
  SWIG_Python_SetConstant(d, "urUpdateFWError",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urUpdateFWError)));
  SWIG_Python_SetConstant(d, "urDevAlreadyInUse",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urDevAlreadyInUse)));
  SWIG_Python_SetConstant(d, "urUpdateFWOK",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urUpdateFWOK)));
  SWIG_Python_SetConstant(d, "urSetDevID",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urSetDevID)));
  SWIG_Python_SetConstant(d, "urSetDevIDError",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urSetDevIDError)));
  SWIG_Python_SetConstant(d, "urSetDevIDInvalidID",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urSetDevIDInvalidID)));
  SWIG_Python_SetConstant(d, "urSetDevIDOK",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urSetDevIDOK)));
  SWIG_Python_SetConstant(d, "urSetUserDataSizeError",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urSetUserDataSizeError)));
  SWIG_Python_SetConstant(d, "urSetUserDataWriteError",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urSetUserDataWriteError)));
  SWIG_Python_SetConstant(d, "urSetUserDataWriteOK",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urSetUserDataWriteOK)));
  SWIG_Python_SetConstant(d, "urGetUserDataReadError",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urGetUserDataReadError)));
  SWIG_Python_SetConstant(d, "urVerifyFWError",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urVerifyFWError)));
  SWIG_Python_SetConstant(d, "urVerifyFWOK",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::urVerifyFWOK)));
  SWIG_Python_SetConstant(d, "I2ComRead",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::I2ComRead)));
  SWIG_Python_SetConstant(d, "I2ComWrite",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::I2ComWrite)));
  SWIG_Python_SetConstant(d, "I2CosSuccess",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::I2CosSuccess)));
  SWIG_Python_SetConstant(d, "I2CosFailure",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::I2CosFailure)));
  SWIG_Python_SetConstant(d, "I2CosInvalidDeviceAddress",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::I2CosInvalidDeviceAddress)));
  SWIG_Python_SetConstant(d, "I2CosInvalidDeviceSubAddress",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::I2CosInvalidDeviceSubAddress)));
  SWIG_Python_SetConstant(d, "I2CosTooMuchData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::I2CosTooMuchData)));
  SWIG_Python_SetConstant(d, "I2CosNotEnoughData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::I2CosNotEnoughData)));
  SWIG_Python_SetConstant(d, "bmpUndefined",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bmpUndefined)));
  SWIG_Python_SetConstant(d, "bmpGR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bmpGR)));
  SWIG_Python_SetConstant(d, "bmpRG",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bmpRG)));
  SWIG_Python_SetConstant(d, "bmpBG",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bmpBG)));
  SWIG_Python_SetConstant(d, "bmpGB",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bmpGB)));
  SWIG_Python_SetConstant(d, "bpdtUnknown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtUnknown)));
  SWIG_Python_SetConstant(d, "bpdt2DImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdt2DImage)));
  SWIG_Python_SetConstant(d, "bpdt2DPlaneBiplanar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdt2DPlaneBiplanar)));
  SWIG_Python_SetConstant(d, "bpdt2DPlaneTriplanar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdt2DPlaneTriplanar)));
  SWIG_Python_SetConstant(d, "bpdt2DPlaneQuadplanar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdt2DPlaneQuadplanar)));
  SWIG_Python_SetConstant(d, "bpdt3DImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdt3DImage)));
  SWIG_Python_SetConstant(d, "bpdt3DPlaneBiplanar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdt3DPlaneBiplanar)));
  SWIG_Python_SetConstant(d, "bpdt3DPlaneTriplanar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdt3DPlaneTriplanar)));
  SWIG_Python_SetConstant(d, "bpdt3DPlaneQuadplanar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdt3DPlaneQuadplanar)));
  SWIG_Python_SetConstant(d, "bpdtConfidenceMap",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtConfidenceMap)));
  SWIG_Python_SetConstant(d, "bpdtGenICamChunkData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtGenICamChunkData)));
  SWIG_Python_SetConstant(d, "bpdtJPEG",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtJPEG)));
  SWIG_Python_SetConstant(d, "bpdtJPEG2000",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtJPEG2000)));
  SWIG_Python_SetConstant(d, "bpdtGDC_GenICamChunkData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtGDC_GenICamChunkData)));
  SWIG_Python_SetConstant(d, "bpdtGDC_GenICamXML",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtGDC_GenICamXML)));
  SWIG_Python_SetConstant(d, "bpdtGDC_2DImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtGDC_2DImage)));
  SWIG_Python_SetConstant(d, "bpdtGDC_JPEG",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtGDC_JPEG)));
  SWIG_Python_SetConstant(d, "bpdtGDC_JPEG2000",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtGDC_JPEG2000)));
  SWIG_Python_SetConstant(d, "bpdtGDC_H264",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::bpdtGDC_H264)));
  SWIG_Python_SetConstant(d, "ibfrmMono8_To_Mono8",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono8_To_Mono8)));
  SWIG_Python_SetConstant(d, "ibfrmMono8_To_RGB888Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono8_To_RGB888Packed)));
  SWIG_Python_SetConstant(d, "ibfrmMono8_To_BGR888Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono8_To_BGR888Packed)));
  SWIG_Python_SetConstant(d, "ibfrmMono10_To_Mono10",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono10_To_Mono10)));
  SWIG_Python_SetConstant(d, "ibfrmMono10_To_RGB101010Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono10_To_RGB101010Packed)));
  SWIG_Python_SetConstant(d, "ibfrmMono12_To_Mono12",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono12_To_Mono12)));
  SWIG_Python_SetConstant(d, "ibfrmMono12_To_RGB121212Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono12_To_RGB121212Packed)));
  SWIG_Python_SetConstant(d, "ibfrmMono14_To_Mono14",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono14_To_Mono14)));
  SWIG_Python_SetConstant(d, "ibfrmMono14_To_RGB141414Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono14_To_RGB141414Packed)));
  SWIG_Python_SetConstant(d, "ibfrmMono16_To_Mono16",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono16_To_Mono16)));
  SWIG_Python_SetConstant(d, "ibfrmMono16_To_RGB161616Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono16_To_RGB161616Packed)));
  SWIG_Python_SetConstant(d, "idpfAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfAuto)));
  SWIG_Python_SetConstant(d, "idpfRaw",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfRaw)));
  SWIG_Python_SetConstant(d, "idpfMono8",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfMono8)));
  SWIG_Python_SetConstant(d, "idpfRGBx888Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfRGBx888Packed)));
  SWIG_Python_SetConstant(d, "idpfYUV422Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV422Packed)));
  SWIG_Python_SetConstant(d, "idpfRGBx888Planar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfRGBx888Planar)));
  SWIG_Python_SetConstant(d, "idpfMono10",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfMono10)));
  SWIG_Python_SetConstant(d, "idpfMono12",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfMono12)));
  SWIG_Python_SetConstant(d, "idpfMono14",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfMono14)));
  SWIG_Python_SetConstant(d, "idpfMono16",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfMono16)));
  SWIG_Python_SetConstant(d, "idpfRGB888Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfRGB888Packed)));
  SWIG_Python_SetConstant(d, "idpfYUV422Planar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV422Planar)));
  SWIG_Python_SetConstant(d, "idpfRGB101010Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfRGB101010Packed)));
  SWIG_Python_SetConstant(d, "idpfRGB121212Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfRGB121212Packed)));
  SWIG_Python_SetConstant(d, "idpfRGB141414Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfRGB141414Packed)));
  SWIG_Python_SetConstant(d, "idpfRGB161616Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfRGB161616Packed)));
  SWIG_Python_SetConstant(d, "idpfYUV422_UYVYPacked",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV422_UYVYPacked)));
  SWIG_Python_SetConstant(d, "idpfMono12Packed_V2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfMono12Packed_V2)));
  SWIG_Python_SetConstant(d, "idpfYUV422_10Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV422_10Packed)));
  SWIG_Python_SetConstant(d, "idpfYUV422_UYVY_10Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV422_UYVY_10Packed)));
  SWIG_Python_SetConstant(d, "idpfBGR888Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfBGR888Packed)));
  SWIG_Python_SetConstant(d, "idpfBGR101010Packed_V2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfBGR101010Packed_V2)));
  SWIG_Python_SetConstant(d, "idpfYUV444_UYVPacked",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV444_UYVPacked)));
  SWIG_Python_SetConstant(d, "idpfYUV444_UYV_10Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV444_UYV_10Packed)));
  SWIG_Python_SetConstant(d, "idpfYUV444Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV444Packed)));
  SWIG_Python_SetConstant(d, "idpfYUV444_10Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV444_10Packed)));
  SWIG_Python_SetConstant(d, "idpfMono12Packed_V1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfMono12Packed_V1)));
  SWIG_Python_SetConstant(d, "idpfYUV411_UYYVYY_Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfYUV411_UYYVYY_Packed)));
  SWIG_Python_SetConstant(d, "idpfRGB888Planar",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::idpfRGB888Planar)));
  SWIG_Python_SetConstant(d, "iffAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iffAuto)));
  SWIG_Python_SetConstant(d, "iffBMP",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iffBMP)));
  SWIG_Python_SetConstant(d, "iffJPEG",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iffJPEG)));
  SWIG_Python_SetConstant(d, "iffPNG",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iffPNG)));
  SWIG_Python_SetConstant(d, "iffTIFF",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iffTIFF)));
  SWIG_Python_SetConstant(d, "ipfOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ipfOff)));
  SWIG_Python_SetConstant(d, "ipfSharpen",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ipfSharpen)));
  SWIG_Python_SetConstant(d, "ipmDefault",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ipmDefault)));
  SWIG_Python_SetConstant(d, "ipmProcessLatestOnly",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ipmProcessLatestOnly)));
  SWIG_Python_SetConstant(d, "ipoMaximizeSpeed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ipoMaximizeSpeed)));
  SWIG_Python_SetConstant(d, "ipoMinimizeMemoryUsage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ipoMinimizeMemoryUsage)));
  SWIG_Python_SetConstant(d, "iprNotActive",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iprNotActive)));
  SWIG_Python_SetConstant(d, "iprApplied",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iprApplied)));
  SWIG_Python_SetConstant(d, "iprFailure",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iprFailure)));
  SWIG_Python_SetConstant(d, "iprSkipped",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iprSkipped)));
  SWIG_Python_SetConstant(d, "iprNotApplicable",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iprNotApplicable)));
  SWIG_Python_SetConstant(d, "ircmManual",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ircmManual)));
  SWIG_Python_SetConstant(d, "ircmLive",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ircmLive)));
  SWIG_Python_SetConstant(d, "ircmCounting",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ircmCounting)));
  SWIG_Python_SetConstant(d, "ircmTrial",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ircmTrial)));
  SWIG_Python_SetConstant(d, "ircmUpdateBufferLayout",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ircmUpdateBufferLayout)));
  SWIG_Python_SetConstant(d, "iscmUnknown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscmUnknown)));
  SWIG_Python_SetConstant(d, "iscmMono",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscmMono)));
  SWIG_Python_SetConstant(d, "iscmBayer",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscmBayer)));
  SWIG_Python_SetConstant(d, "iscmColor",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscmColor)));
  SWIG_Python_SetConstant(d, "iscmNIR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscmNIR)));
  SWIG_Python_SetConstant(d, "iscpGreenRed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscpGreenRed)));
  SWIG_Python_SetConstant(d, "iscpRedGreen",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscpRedGreen)));
  SWIG_Python_SetConstant(d, "iscpBlueGreen",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscpBlueGreen)));
  SWIG_Python_SetConstant(d, "iscpGreenBlue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscpGreenBlue)));
  SWIG_Python_SetConstant(d, "iscpUnknown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iscpUnknown)));
  SWIG_Python_SetConstant(d, "istUnknown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::istUnknown)));
  SWIG_Python_SetConstant(d, "istCCD",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::istCCD)));
  SWIG_Python_SetConstant(d, "istCMOS",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::istCMOS)));
  SWIG_Python_SetConstant(d, "iebNotConfigured",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iebNotConfigured)));
  SWIG_Python_SetConstant(d, "iebForceIgnore",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iebForceIgnore)));
  SWIG_Python_SetConstant(d, "iebForceEnumerate",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::iebForceEnumerate)));
  SWIG_Python_SetConstant(d, "imOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::imOn)));
  SWIG_Python_SetConstant(d, "imOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::imOff)));
  SWIG_Python_SetConstant(d, "lcOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::lcOff)));
  SWIG_Python_SetConstant(d, "lcOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::lcOn)));
  SWIG_Python_SetConstant(d, "LUTgmStandard",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTgmStandard)));
  SWIG_Python_SetConstant(d, "LUTgmLinearStart",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTgmLinearStart)));
  SWIG_Python_SetConstant(d, "LUTiHardware",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTiHardware)));
  SWIG_Python_SetConstant(d, "LUTiSoftware",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTiSoftware)));
  SWIG_Python_SetConstant(d, "LUTimThreshold",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTimThreshold)));
  SWIG_Python_SetConstant(d, "LUTimLinear",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTimLinear)));
  SWIG_Python_SetConstant(d, "LUTimCubic",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTimCubic)));
  SWIG_Python_SetConstant(d, "LUTm8To8",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTm8To8)));
  SWIG_Python_SetConstant(d, "LUTm10To8",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTm10To8)));
  SWIG_Python_SetConstant(d, "LUTm10To10",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTm10To10)));
  SWIG_Python_SetConstant(d, "LUTm12To10",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTm12To10)));
  SWIG_Python_SetConstant(d, "LUTm12To12",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTm12To12)));
  SWIG_Python_SetConstant(d, "LUTm14To14",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTm14To14)));
  SWIG_Python_SetConstant(d, "LUTm16To16",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTm16To16)));
  SWIG_Python_SetConstant(d, "LUTmInterpolated",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTmInterpolated)));
  SWIG_Python_SetConstant(d, "LUTmGamma",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTmGamma)));
  SWIG_Python_SetConstant(d, "LUTmDirect",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::LUTmDirect)));
  SWIG_Python_SetConstant(d, "mmmAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::mmmAuto)));
  SWIG_Python_SetConstant(d, "mmmPool",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::mmmPool)));
  SWIG_Python_SetConstant(d, "mmpmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::mmpmOff)));
  SWIG_Python_SetConstant(d, "mmpmFixed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::mmpmFixed)));
  SWIG_Python_SetConstant(d, "mmpmAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::mmpmAuto)));
  SWIG_Python_SetConstant(d, "mmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::mmOff)));
  SWIG_Python_SetConstant(d, "mmTopDown",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::mmTopDown)));
  SWIG_Python_SetConstant(d, "mmLeftRight",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::mmLeftRight)));
  SWIG_Python_SetConstant(d, "mmTopDownAndLeftRight",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::mmTopDownAndLeftRight)));
  SWIG_Python_SetConstant(d, "momGlobal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::momGlobal)));
  SWIG_Python_SetConstant(d, "momChannelBased",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::momChannelBased)));
  SWIG_Python_SetConstant(d, "obmmDefault",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::obmmDefault)));
  SWIG_Python_SetConstant(d, "obmmUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::obmmUser)));
  SWIG_Python_SetConstant(d, "prmVertical",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::prmVertical)));
  SWIG_Python_SetConstant(d, "prmHorizontal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::prmHorizontal)));
  SWIG_Python_SetConstant(d, "prmExtractSingle",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::prmExtractSingle)));
  SWIG_Python_SetConstant(d, "prmMinimumValue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::prmMinimumValue)));
  SWIG_Python_SetConstant(d, "prmMeanValue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::prmMeanValue)));
  SWIG_Python_SetConstant(d, "prm2By2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::prm2By2)));
  SWIG_Python_SetConstant(d, "prmExtractAngle",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::prmExtractAngle)));
  SWIG_Python_SetConstant(d, "prmExtractDegree",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::prmExtractDegree)));
  SWIG_Python_SetConstant(d, "prmPseudoColorRepresentation",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::prmPseudoColorRepresentation)));
  SWIG_Python_SetConstant(d, "primOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::primOff)));
  SWIG_Python_SetConstant(d, "primLinear",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::primLinear)));
  SWIG_Python_SetConstant(d, "pstDigitalSignal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::pstDigitalSignal)));
  SWIG_Python_SetConstant(d, "pstPeriodically",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::pstPeriodically)));
  SWIG_Python_SetConstant(d, "pstRotaryDecoder",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::pstRotaryDecoder)));
  SWIG_Python_SetConstant(d, "rimmAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rimmAuto)));
  SWIG_Python_SetConstant(d, "rimmUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rimmUser)));
  SWIG_Python_SetConstant(d, "rrOK",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrOK)));
  SWIG_Python_SetConstant(d, "rrTimeout",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrTimeout)));
  SWIG_Python_SetConstant(d, "rrError",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrError)));
  SWIG_Python_SetConstant(d, "rrRequestAborted",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrRequestAborted)));
  SWIG_Python_SetConstant(d, "rrFrameIncomplete",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrFrameIncomplete)));
  SWIG_Python_SetConstant(d, "rrDeviceAccessLost",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrDeviceAccessLost)));
  SWIG_Python_SetConstant(d, "rrInconsistentBufferContent",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrInconsistentBufferContent)));
  SWIG_Python_SetConstant(d, "rrFrameCorrupt",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrFrameCorrupt)));
  SWIG_Python_SetConstant(d, "rrUnprocessibleRequest",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrUnprocessibleRequest)));
  SWIG_Python_SetConstant(d, "rrNoBufferAvailable",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrNoBufferAvailable)));
  SWIG_Python_SetConstant(d, "rrNotEnoughMemory",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrNotEnoughMemory)));
  SWIG_Python_SetConstant(d, "rrCameraNotSupported",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrCameraNotSupported)));
  SWIG_Python_SetConstant(d, "rrDataAcquisitionNotSupported",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rrDataAcquisitionNotSupported)));
  SWIG_Python_SetConstant(d, "rsIdle",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rsIdle)));
  SWIG_Python_SetConstant(d, "rsWaiting",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rsWaiting)));
  SWIG_Python_SetConstant(d, "rsCapturing",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rsCapturing)));
  SWIG_Python_SetConstant(d, "rsReady",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rsReady)));
  SWIG_Python_SetConstant(d, "rsBeingConfigured",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rsBeingConfigured)));
  SWIG_Python_SetConstant(d, "rtctrlModeStop",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlModeStop)));
  SWIG_Python_SetConstant(d, "rtctrlModeRun",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlModeRun)));
  SWIG_Python_SetConstant(d, "rtctrlModeRunRestart",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlModeRunRestart)));
  SWIG_Python_SetConstant(d, "rtctrlProgNop",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgNop)));
  SWIG_Python_SetConstant(d, "rtctrlProgSetDigout",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgSetDigout)));
  SWIG_Python_SetConstant(d, "rtctrlProgWaitDigin",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgWaitDigin)));
  SWIG_Python_SetConstant(d, "rtctrlProgWaitClocks",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgWaitClocks)));
  SWIG_Python_SetConstant(d, "rtctrlProgJumpLoc",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgJumpLoc)));
  SWIG_Python_SetConstant(d, "rtctrlProgTriggerSet",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgTriggerSet)));
  SWIG_Python_SetConstant(d, "rtctrlProgTriggerReset",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgTriggerReset)));
  SWIG_Python_SetConstant(d, "rtctrlProgExposeSet",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgExposeSet)));
  SWIG_Python_SetConstant(d, "rtctrlProgExposeReset",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgExposeReset)));
  SWIG_Python_SetConstant(d, "rtctrlProgFrameNrReset",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgFrameNrReset)));
  SWIG_Python_SetConstant(d, "rtctrlProgJumpLocOnZero",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgJumpLocOnZero)));
  SWIG_Python_SetConstant(d, "rtctrlProgJumpLocOnNotZero",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgJumpLocOnNotZero)));
  SWIG_Python_SetConstant(d, "rtctrlProgRegisterSet",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgRegisterSet)));
  SWIG_Python_SetConstant(d, "rtctrlProgRegisterAdd",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgRegisterAdd)));
  SWIG_Python_SetConstant(d, "rtctrlProgRegisterSub",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::rtctrlProgRegisterSub)));
  SWIG_Python_SetConstant(d, "simNearestNeighbor",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::simNearestNeighbor)));
  SWIG_Python_SetConstant(d, "simLinear",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::simLinear)));
  SWIG_Python_SetConstant(d, "simCubic",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::simCubic)));
  SWIG_Python_SetConstant(d, "smOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::smOff)));
  SWIG_Python_SetConstant(d, "smOn",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::smOn)));
  SWIG_Python_SetConstant(d, "scAuto",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::scAuto)));
  SWIG_Python_SetConstant(d, "scAnalogue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::scAnalogue)));
  SWIG_Python_SetConstant(d, "scDigital",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::scDigital)));
  SWIG_Python_SetConstant(d, "ssITU601",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ssITU601)));
  SWIG_Python_SetConstant(d, "ssSquare",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ssSquare)));
  SWIG_Python_SetConstant(d, "ssUser",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ssUser)));
  SWIG_Python_SetConstant(d, "tmOnFallingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::tmOnFallingEdge)));
  SWIG_Python_SetConstant(d, "tmOnRisingEdge",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::tmOnRisingEdge)));
  SWIG_Python_SetConstant(d, "udarRead",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::udarRead)));
  SWIG_Python_SetConstant(d, "udarWrite",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::udarWrite)));
  SWIG_Python_SetConstant(d, "udarRW",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::udarRW)));
  SWIG_Python_SetConstant(d, "udarPassword",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::udarPassword)));
  SWIG_Python_SetConstant(d, "udarFull",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::udarFull)));
  SWIG_Python_SetConstant(d, "udrbKeepCachedData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::udrbKeepCachedData)));
  SWIG_Python_SetConstant(d, "udrbUpdateFromDeviceData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::udrbUpdateFromDeviceData)));
  SWIG_Python_SetConstant(d, "vcMPEG2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vcMPEG2)));
  SWIG_Python_SetConstant(d, "vcH264",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vcH264)));
  SWIG_Python_SetConstant(d, "vcH265",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vcH265)));
  SWIG_Python_SetConstant(d, "vsCCIR",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vsCCIR)));
  SWIG_Python_SetConstant(d, "vsRS170",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vsRS170)));
  SWIG_Python_SetConstant(d, "vsPALBGH",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vsPALBGH)));
  SWIG_Python_SetConstant(d, "vsNTSCM",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vsNTSCM)));
  SWIG_Python_SetConstant(d, "vsSDI480i",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vsSDI480i)));
  SWIG_Python_SetConstant(d, "vsSDI576i",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vsSDI576i)));
  SWIG_Python_SetConstant(d, "vsSDI720p",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vsSDI720p)));
  SWIG_Python_SetConstant(d, "vsSDI1080i",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vsSDI1080i)));
  SWIG_Python_SetConstant(d, "vsSDI1080p",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vsSDI1080p)));
  SWIG_Python_SetConstant(d, "vditNone",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vditNone)));
  SWIG_Python_SetConstant(d, "vditBMP",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vditBMP)));
  SWIG_Python_SetConstant(d, "vditPGM",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vditPGM)));
  SWIG_Python_SetConstant(d, "vditPNG",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vditPNG)));
  SWIG_Python_SetConstant(d, "vditJPG",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vditJPG)));
  SWIG_Python_SetConstant(d, "vditTIFF",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vditTIFF)));
  SWIG_Python_SetConstant(d, "vditALL",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vditALL)));
  SWIG_Python_SetConstant(d, "vdtmMovingRGBx888PackedImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingRGBx888PackedImage)));
  SWIG_Python_SetConstant(d, "vdtmMovingRGB888PackedImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingRGB888PackedImage)));
  SWIG_Python_SetConstant(d, "vdtmMovingRGBx888PlanarImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingRGBx888PlanarImage)));
  SWIG_Python_SetConstant(d, "vdtmMovingMonoRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingMonoRamp)));
  SWIG_Python_SetConstant(d, "vdtmMovingYUV422PackedRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingYUV422PackedRamp)));
  SWIG_Python_SetConstant(d, "vdtmMovingYUV422PlanarRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingYUV422PlanarRamp)));
  SWIG_Python_SetConstant(d, "vdtmMovingRGB101010PackedImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingRGB101010PackedImage)));
  SWIG_Python_SetConstant(d, "vdtmMovingRGB121212PackedImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingRGB121212PackedImage)));
  SWIG_Python_SetConstant(d, "vdtmMovingRGB141414PackedImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingRGB141414PackedImage)));
  SWIG_Python_SetConstant(d, "vdtmMovingRGB161616PackedImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingRGB161616PackedImage)));
  SWIG_Python_SetConstant(d, "vdtmMovingBayerDataRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingBayerDataRamp)));
  SWIG_Python_SetConstant(d, "vdtmBayerWhiteBalanceTestImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmBayerWhiteBalanceTestImage)));
  SWIG_Python_SetConstant(d, "vdtmImageDirectory",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmImageDirectory)));
  SWIG_Python_SetConstant(d, "vdtmLeakyPixelTestImageMono8Bayer",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmLeakyPixelTestImageMono8Bayer)));
  SWIG_Python_SetConstant(d, "vdtmMovingYUV422_UYVYPackedRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingYUV422_UYVYPackedRamp)));
  SWIG_Python_SetConstant(d, "vdtmHorizontalMonoRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmHorizontalMonoRamp)));
  SWIG_Python_SetConstant(d, "vdtmVerticalMonoRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmVerticalMonoRamp)));
  SWIG_Python_SetConstant(d, "vdtmMovingVerticalMonoRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingVerticalMonoRamp)));
  SWIG_Python_SetConstant(d, "vdtmHorizontalMono12Packed_V2Ramp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmHorizontalMono12Packed_V2Ramp)));
  SWIG_Python_SetConstant(d, "vdtmMovingBGR888PackedImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingBGR888PackedImage)));
  SWIG_Python_SetConstant(d, "vdtmMovingYUV444PackedRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingYUV444PackedRamp)));
  SWIG_Python_SetConstant(d, "vdtmMovingYUV444_UYVPackedRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingYUV444_UYVPackedRamp)));
  SWIG_Python_SetConstant(d, "vdtmMovingBGRPacked_V2Image",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingBGRPacked_V2Image)));
  SWIG_Python_SetConstant(d, "vdtmEmptyMonoBuffer",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmEmptyMonoBuffer)));
  SWIG_Python_SetConstant(d, "vdtmHorizontalMono12Packed_V1Ramp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmHorizontalMono12Packed_V1Ramp)));
  SWIG_Python_SetConstant(d, "vdtmHorizontalBayer12Packed_V1Ramp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmHorizontalBayer12Packed_V1Ramp)));
  SWIG_Python_SetConstant(d, "vdtmHorizontalBayer12Packed_V2Ramp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmHorizontalBayer12Packed_V2Ramp)));
  SWIG_Python_SetConstant(d, "vdtmMovingYUV411_UYYVYY_PackedRamp",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingYUV411_UYYVYY_PackedRamp)));
  SWIG_Python_SetConstant(d, "vdtmMovingRGB888PlanarImage",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmMovingRGB888PlanarImage)));
  SWIG_Python_SetConstant(d, "vdtmHotAndColdPixelTestImageBayer",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmHotAndColdPixelTestImageBayer)));
  SWIG_Python_SetConstant(d, "vdtmHotAndColdPixelTestImageRGB888Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmHotAndColdPixelTestImageRGB888Packed)));
  SWIG_Python_SetConstant(d, "wbcmOff",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbcmOff)));
  SWIG_Python_SetConstant(d, "wbcmNextFrame",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbcmNextFrame)));
  SWIG_Python_SetConstant(d, "wbcmContinuous",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbcmContinuous)));
  SWIG_Python_SetConstant(d, "wbpTungsten",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpTungsten)));
  SWIG_Python_SetConstant(d, "wbpHalogen",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpHalogen)));
  SWIG_Python_SetConstant(d, "wbpFluorescent",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpFluorescent)));
  SWIG_Python_SetConstant(d, "wbpDayLight",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpDayLight)));
  SWIG_Python_SetConstant(d, "wbpPhotoFlash",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpPhotoFlash)));
  SWIG_Python_SetConstant(d, "wbpBlueSky",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpBlueSky)));
  SWIG_Python_SetConstant(d, "wbpUser1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpUser1)));
  SWIG_Python_SetConstant(d, "wbpUser2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpUser2)));
  SWIG_Python_SetConstant(d, "wbpUser3",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpUser3)));
  SWIG_Python_SetConstant(d, "wbpUser4",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::wbpUser4)));
  SWIG_Python_SetConstant(d, "irpPixelFormat",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::irpPixelFormat)));
  SWIG_Python_SetConstant(d, "irpResult",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::irpResult)));
  SWIG_Python_SetConstant(d, "irpState",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::irpState)));
  SWIG_Python_SetConstant(d, "irpCameraOutputUsed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::irpCameraOutputUsed)));
  SWIG_Python_SetConstant(d, "ibfNone",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfNone)));
  SWIG_Python_SetConstant(d, "ibfUseRequestMemory",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfUseRequestMemory)));
  SWIG_Python_SetConstant(d, "ibfRecycleBufHandle",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfRecycleBufHandle)));
  SWIG_Python_SetConstant(d, "lqDeviceManager",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::lqDeviceManager)));
  SWIG_Python_SetConstant(d, "lqPropHandling",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::lqPropHandling)));
  SWIG_Python_SetConstant(d, "plMaxValue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::plMaxValue)));
  SWIG_Python_SetConstant(d, "plMinValue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::plMinValue)));
  SWIG_Python_SetConstant(d, "plStepWidth",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::plStepWidth)));
  SWIG_Python_SetConstant(d, "dltUndefined",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltUndefined)));
  SWIG_Python_SetConstant(d, "dltSetting",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltSetting)));
  SWIG_Python_SetConstant(d, "dltRequest",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltRequest)));
  SWIG_Python_SetConstant(d, "dltRequestCtrl",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltRequestCtrl)));
  SWIG_Python_SetConstant(d, "dltInfo",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltInfo)));
  SWIG_Python_SetConstant(d, "dltStatistics",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltStatistics)));
  SWIG_Python_SetConstant(d, "dltSystemSettings",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltSystemSettings)));
  SWIG_Python_SetConstant(d, "dltIOSubSystem",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltIOSubSystem)));
  SWIG_Python_SetConstant(d, "dltRTCtr",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltRTCtr)));
  SWIG_Python_SetConstant(d, "dltCameraDescriptions",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltCameraDescriptions)));
  SWIG_Python_SetConstant(d, "dltDeviceSpecificData",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltDeviceSpecificData)));
  SWIG_Python_SetConstant(d, "dltImageMemoryManager",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltImageMemoryManager)));
  SWIG_Python_SetConstant(d, "dltPseudoLast",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltPseudoLast)));
  SWIG_Python_SetConstant(d, "dltLast",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltLast)));
  SWIG_Python_SetConstant(d, "rtmFullResolution",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::rtmFullResolution)));
  SWIG_Python_SetConstant(d, "sspCounterDuration_Counter1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspCounterDuration_Counter1)));
  SWIG_Python_SetConstant(d, "sspCounterDuration_Counter2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspCounterDuration_Counter2)));
  SWIG_Python_SetConstant(d, "sspCounterDuration_Counter3",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspCounterDuration_Counter3)));
  SWIG_Python_SetConstant(d, "sspCounterDuration_Counter4",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspCounterDuration_Counter4)));
  SWIG_Python_SetConstant(d, "sspCounterDuration_Counter5",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspCounterDuration_Counter5)));
  SWIG_Python_SetConstant(d, "sspCounterDuration_Counter6",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspCounterDuration_Counter6)));
  SWIG_Python_SetConstant(d, "sspCounterDuration_Counter7",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspCounterDuration_Counter7)));
  SWIG_Python_SetConstant(d, "sspCounterDuration_Counter8",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspCounterDuration_Counter8)));
  SWIG_Python_SetConstant(d, "sspExposureTime",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspExposureTime)));
  SWIG_Python_SetConstant(d, "sspGain_AnalogAll",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspGain_AnalogAll)));
  SWIG_Python_SetConstant(d, "sspGain_AnalogRed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspGain_AnalogRed)));
  SWIG_Python_SetConstant(d, "sspGain_AnalogGreen",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspGain_AnalogGreen)));
  SWIG_Python_SetConstant(d, "sspGain_AnalogBlue",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspGain_AnalogBlue)));
  SWIG_Python_SetConstant(d, "sspGain_AnalogTap1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspGain_AnalogTap1)));
  SWIG_Python_SetConstant(d, "sspGain_AnalogTap2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspGain_AnalogTap2)));
  SWIG_Python_SetConstant(d, "sspGain_AnalogTap3",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspGain_AnalogTap3)));
  SWIG_Python_SetConstant(d, "sspGain_AnalogTap4",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspGain_AnalogTap4)));
  SWIG_Python_SetConstant(d, "sspOffsetX",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspOffsetX)));
  SWIG_Python_SetConstant(d, "sspOffsetY",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspOffsetY)));
  SWIG_Python_SetConstant(d, "sspWidth",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspWidth)));
  SWIG_Python_SetConstant(d, "sspHeight",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspHeight)));
  SWIG_Python_SetConstant(d, "sspBinningVertical",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspBinningVertical)));
  SWIG_Python_SetConstant(d, "sspBinningHorizontal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspBinningHorizontal)));
  SWIG_Python_SetConstant(d, "sspDecimationVertical",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspDecimationVertical)));
  SWIG_Python_SetConstant(d, "sspDecimationHorizontal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::GenICam::sspDecimationHorizontal)));
  
  /* Initialize threading */
  SWIG_PYTHON_INITIALIZE_THREADS;
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

